@vaharoni/devops 1.0.47

package/dist/libs/validate-env.d.ts

@@ -0,0 +1,56 @@
+type EnvRequirement = 'optional' | 'boolean' | 'required' | string[];
+type ParsedEnvYaml = Record<string, EnvRequirement>;
+type CombinedErrors = Record<string, string[]>;
+type KeysFromFiles = Record<string, string[]>;
+export declare class CombinedEnvValidator {
+    envYamlPaths: string[];
+    dotEnvPaths: string[];
+    yamlValidators: SingleEnvValidator[];
+    dotEnvParsers: DotEnvParser[];
+    keysFromYamlFiles: Set<string>;
+    keysFromDotEnvFiles: KeysFromFiles;
+    errors: CombinedErrors;
+    warnings: string[];
+    constructor(envYamlPaths: string[], dotEnvPaths?: string[]);
+    validate(): void;
+    _handleYamlFiles(): void;
+    _handleDotEnvFiles(): void;
+    _loadYamlFiles(envYamlPaths: string[]): void;
+    _validateYamlFiles(): void;
+    _haltIfParsingErrors(): void;
+    _extractErrors(): void;
+    _loadDotEnvFiles(dotEnvPaths?: string[]): void;
+    _parseDotEnvFiles(): void;
+    _combineDotEnvFiles(): void;
+    _extractWarnings(): void;
+    _finalize(): void;
+}
+/**
+ * While we don't strictly need to parse .env files (we can simply use process.env), it is useful to give
+ * warnings to the user that there are unused entries in .env files compared to the stated requirements
+ * captured in env.yaml files.
+ */
+export declare class DotEnvParser {
+    path: string;
+    keys: string[] | undefined;
+    constructor(path: string);
+    parse(): void;
+    _readFile(path: string): string | undefined;
+    _parse(text: string): string[];
+}
+export declare class SingleEnvValidator {
+    envYamlPath: string;
+    parsedEnvYaml: ParsedEnvYaml | undefined;
+    parsingError: string | undefined;
+    errors: Record<string, string>;
+    constructor(envYamlPath: string);
+    validate(): void;
+    _readFile(): any;
+    _generateError(message: string): string;
+    _setParsingError(message: string): void;
+    _addError(key: string, message: string): void;
+    _parse(): ParsedEnvYaml | undefined;
+    _addAllErrors(): void;
+}
+export {};
+//# sourceMappingURL=validate-env.d.ts.map

package/dist/libs/validate-env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-env.d.ts","sourceRoot":"","sources":["../../src/libs/validate-env.ts"],"names":[],"mappings":"AAIA,KAAK,cAAc,GAAG,UAAU,GAAG,SAAS,GAAG,UAAU,GAAG,MAAM,EAAE,CAAC;AACrE,KAAK,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;AACpD,KAAK,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;AAC/C,KAAK,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;AAE9C,qBAAa,oBAAoB;IAC/B,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,WAAW,EAAE,MAAM,EAAE,CAAC;IAEtB,cAAc,EAAE,kBAAkB,EAAE,CAAM;IAC1C,aAAa,EAAE,YAAY,EAAE,CAAM;IAEnC,iBAAiB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAa;IAC3C,mBAAmB,EAAE,aAAa,CAAM;IAExC,MAAM,EAAE,cAAc,CAAM;IAC5B,QAAQ,EAAE,MAAM,EAAE,CAAM;gBAEZ,YAAY,EAAE,MAAM,EAAE,EAAE,WAAW,GAAE,MAAM,EAAO;IAO9D,QAAQ;IAMR,gBAAgB;IAOhB,kBAAkB;IAOlB,cAAc,CAAC,YAAY,EAAE,MAAM,EAAE;IAOrC,kBAAkB;IAIlB,oBAAoB;IAapB,cAAc;IAYd,gBAAgB,CAAC,WAAW,GAAE,MAAM,EAAO;IAO3C,iBAAiB;IAIjB,mBAAmB;IAUnB,gBAAgB;IAShB,SAAS;CAkBV;AAED;;;;GAIG;AACH,qBAAa,YAAY;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;gBAEf,IAAI,EAAE,MAAM;IAIxB,KAAK;IAKL,SAAS,CAAC,IAAI,EAAE,MAAM;IAKtB,MAAM,CAAC,IAAI,EAAE,MAAM;CAWpB;AAED,qBAAa,kBAAkB;IAC7B,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,aAAa,GAAG,SAAS,CAAC;IACzC,YAAY,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAM;gBAExB,WAAW,EAAE,MAAM;IAI/B,QAAQ;IAKR,SAAS;IAQT,cAAc,CAAC,OAAO,EAAE,MAAM;IAI9B,gBAAgB,CAAC,OAAO,EAAE,MAAM;IAIhC,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;IAItC,MAAM;IAmCN,aAAa;CAwBd"}

package/dist/libs/validate-env.js

@@ -0,0 +1,214 @@
+import fs from 'fs';
+import yaml from 'yaml';
+import { IGNORED_PATHS } from './discovery/process-common';
+export class CombinedEnvValidator {
+    envYamlPaths;
+    dotEnvPaths;
+    yamlValidators = [];
+    dotEnvParsers = [];
+    keysFromYamlFiles = new Set();
+    keysFromDotEnvFiles = {};
+    errors = {};
+    warnings = [];
+    constructor(envYamlPaths, dotEnvPaths = []) {
+        this.envYamlPaths = envYamlPaths.filter(path => !IGNORED_PATHS.some((ignoredPath) => path.includes(ignoredPath)));
+        this.dotEnvPaths = dotEnvPaths;
+    }
+    validate() {
+        this._handleYamlFiles();
+        this._handleDotEnvFiles();
+        this._finalize();
+    }
+    _handleYamlFiles() {
+        this._loadYamlFiles(this.envYamlPaths);
+        this._validateYamlFiles();
+        this._haltIfParsingErrors();
+        this._extractErrors();
+    }
+    _handleDotEnvFiles() {
+        this._loadDotEnvFiles(this.dotEnvPaths);
+        this._parseDotEnvFiles();
+        this._combineDotEnvFiles();
+        this._extractWarnings();
+    }
+    _loadYamlFiles(envYamlPaths) {
+        envYamlPaths.forEach((path) => {
+            const validator = new SingleEnvValidator(path);
+            this.yamlValidators.push(validator);
+        });
+    }
+    _validateYamlFiles() {
+        this.yamlValidators.forEach((x) => x.validate());
+    }
+    _haltIfParsingErrors() {
+        const filesWithParsingErrors = this.yamlValidators.filter((validator) => Boolean(validator.parsingError));
+        if (filesWithParsingErrors.length === 0)
+            return;
+        console.error('The following env.yaml files have parsing errors:');
+        filesWithParsingErrors.forEach((validator) => {
+            console.error(`\t${validator.parsingError}`);
+        });
+        process.exit(1);
+    }
+    _extractErrors() {
+        this.yamlValidators.forEach((validator) => {
+            Object.keys(validator.parsedEnvYaml ?? {}).forEach((envVar) => {
+                this.keysFromYamlFiles.add(envVar);
+            });
+            Object.entries(validator.errors).forEach(([envVar, error]) => {
+                this.errors[envVar] ??= [];
+                this.errors[envVar].push(error);
+            });
+        });
+    }
+    _loadDotEnvFiles(dotEnvPaths = []) {
+        dotEnvPaths.forEach((path) => {
+            const parser = new DotEnvParser(path);
+            this.dotEnvParsers.push(parser);
+        });
+    }
+    _parseDotEnvFiles() {
+        this.dotEnvParsers.forEach((x) => x.parse());
+    }
+    _combineDotEnvFiles() {
+        this.dotEnvParsers.forEach((parser) => {
+            if (!parser.keys)
+                return;
+            parser.keys.forEach((key) => {
+                this.keysFromDotEnvFiles[key] ??= [];
+                this.keysFromDotEnvFiles[key].push(parser.path);
+            });
+        });
+    }
+    _extractWarnings() {
+        const unusedKeys = Object.keys(this.keysFromDotEnvFiles).filter((x) => !this.keysFromYamlFiles.has(x));
+        unusedKeys.forEach((x) => {
+            this.warnings.push(`${x} in: ${this.keysFromDotEnvFiles[x].join(', ')}`);
+        });
+    }
+    _finalize() {
+        if (this.warnings.length > 0) {
+            console.error('WARNING: some env variables exist in .env but not in env.yaml:');
+            this.warnings.forEach((warning) => console.error(`\t${warning}`));
+            console.error();
+        }
+        if (Object.keys(this.errors).length > 0) {
+            Object.entries(this.errors).forEach(([key, errors]) => {
+                console.error(`Errors for ${key}:`);
+                errors.forEach((error) => console.error(`\t${error}`));
+                console.error();
+            });
+            console.error();
+            process.exit(1);
+        }
+    }
+}
+/**
+ * While we don't strictly need to parse .env files (we can simply use process.env), it is useful to give
+ * warnings to the user that there are unused entries in .env files compared to the stated requirements
+ * captured in env.yaml files.
+ */
+export class DotEnvParser {
+    path;
+    keys;
+    constructor(path) {
+        this.path = path;
+    }
+    parse() {
+        const text = this._readFile(this.path);
+        if (text)
+            this.keys = this._parse(text);
+    }
+    _readFile(path) {
+        if (!fs.existsSync(path))
+            return;
+        return fs.readFileSync(path).toString();
+    }
+    _parse(text) {
+        const lines = text.split('\n');
+        const withoutComments = lines
+            .map((x) => x.replace(/#.*$/, '').trim())
+            .filter(Boolean);
+        const keys = withoutComments
+            .map((x) => x.split('=').map((y) => y.trim()))
+            .filter((x) => x.length > 1)
+            .map((x) => x[0]);
+        return keys;
+    }
+}
+export class SingleEnvValidator {
+    envYamlPath;
+    parsedEnvYaml;
+    parsingError;
+    errors = {};
+    constructor(envYamlPath) {
+        this.envYamlPath = envYamlPath;
+    }
+    validate() {
+        this.parsedEnvYaml = this._parse();
+        if (!this.parsingError)
+            this._addAllErrors();
+    }
+    _readFile() {
+        if (!fs.existsSync(this.envYamlPath)) {
+            console.error(`Skipping ${this.envYamlPath}: does not exist`);
+            return;
+        }
+        return yaml.parse(fs.readFileSync(this.envYamlPath).toString());
+    }
+    _generateError(message) {
+        return `Error in ${this.envYamlPath}: ${message}`;
+    }
+    _setParsingError(message) {
+        this.parsingError = this._generateError(message);
+    }
+    _addError(key, message) {
+        this.errors[key] = this._generateError(message);
+    }
+    _parse() {
+        const allEnv = {};
+        const envManifest = this._readFile();
+        if (!envManifest)
+            return;
+        if (!(envManifest instanceof Array)) {
+            this._setParsingError(`env.yaml file must resolve to an array`);
+            return;
+        }
+        envManifest.forEach((env) => {
+            if (env instanceof Object) {
+                const entries = Object.entries(env);
+                if (entries.length > 1) {
+                    this._setParsingError(`every object in env.yaml must have one key. Error near: ${entries[0][0]}`);
+                    return;
+                }
+                const [name, value] = entries[0];
+                if (!(value instanceof Array) &&
+                    !['optional', 'boolean'].includes(value)) {
+                    this._setParsingError(`invalid value for ${name}: ${JSON.stringify(value)}`);
+                    return;
+                }
+                allEnv[name] = value;
+            }
+            else {
+                allEnv[env] = 'required';
+            }
+        });
+        return allEnv;
+    }
+    _addAllErrors() {
+        Object.entries(this.parsedEnvYaml).forEach(([key, requirement]) => {
+            const value = process.env[key];
+            if (requirement !== 'optional' && !value) {
+                this._addError(key, `${key} is required but missing`);
+            }
+            else if (requirement === 'boolean' &&
+                !['true', 'false'].includes(String(value))) {
+                this._addError(key, `${key} must be either true or false. Value: ${value}`);
+            }
+            else if (requirement instanceof Array &&
+                !requirement.includes(value ?? '')) {
+                this._addError(key, `${key} must be one of ${requirement.join(', ')}. Value: ${value}`);
+            }
+        });
+    }
+}

package/dist/libs/validate-env.spec.d.ts

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

package/dist/libs/validate-env.spec.d.ts.map

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

package/dist/libs/validate-env.spec.js

@@ -0,0 +1,168 @@
+import { describe, expect, it, vi } from 'vitest';
+import { CombinedEnvValidator, DotEnvParser, SingleEnvValidator, } from './validate-env';
+// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+function withEnvVars(envVars, callbackFn) {
+    Object.entries(envVars).forEach(([key, value]) => (process.env[key] = value));
+    try {
+        callbackFn();
+    }
+    finally {
+        Object.keys(envVars).forEach((key) => delete process.env[key]);
+    }
+}
+describe('SingleEnvValidator', () => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    function createSubject(yamlContent) {
+        const subject = new SingleEnvValidator('dummy-path.yaml');
+        vi.spyOn(subject, '_readFile').mockReturnValue(yamlContent);
+        return subject;
+    }
+    describe('invalid yaml files', () => {
+        it('contains parsingError when not an array', () => {
+            const subject = createSubject({ DUMMY1: 'optional' });
+            subject.validate();
+            expect(subject.parsingError).toContain('env.yaml file must resolve to an array');
+        });
+        it('contains parsingError when an object has multiple keys', () => {
+            const subject = createSubject([
+                { DUMMY1: 'optional', DUMMY2: 'optional' },
+            ]);
+            subject.validate();
+            expect(subject.parsingError).toContain('every object in env.yaml must have one key. Error near: DUMMY1');
+        });
+        it('contains parsingError when an object has invalid requirement', () => {
+            const subject = createSubject([{ DUMMY1: 'optttttttional' }]);
+            subject.validate();
+            expect(subject.parsingError).toContain('invalid value for DUMMY1');
+        });
+    });
+    describe('valid yaml file', () => {
+        const validYaml = [
+            'TEST_ENV_MANDATORY',
+            { TEST_ENV_OPTIONAL: 'optional' },
+            { TEST_ENV_BOOLEAN1: 'boolean' },
+            { TEST_ENV_BOOLEAN2: 'boolean' },
+            { TEST_ENV_ENUM1: ['option1', 'option2'] },
+            { TEST_ENV_ENUM2: ['option1', 'option2'] },
+        ];
+        const defaultValues = {
+            TEST_ENV_MANDATORY: 'some_value',
+            TEST_ENV_BOOLEAN1: 'true',
+            TEST_ENV_BOOLEAN2: 'false',
+            TEST_ENV_ENUM1: 'option1',
+            TEST_ENV_ENUM2: 'option2',
+        };
+        function withEnvVarsHelper(envVars, 
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+        callbackFn) {
+            envVars = { ...defaultValues, ...envVars };
+            withEnvVars(envVars, callbackFn);
+        }
+        it('works when all env vars are provided as expected', () => {
+            const subject = createSubject(validYaml);
+            withEnvVarsHelper({}, () => subject.validate());
+            expect(subject.parsingError).toEqual(undefined);
+            expect(subject.errors).toEqual({});
+        });
+        it('works when an optional varilable is provided', () => {
+            const subject = createSubject(validYaml);
+            withEnvVarsHelper({ TEST_ENV_OPTIONAL: 'value' }, () => subject.validate());
+            expect(subject.parsingError).toEqual(undefined);
+            expect(subject.errors).toEqual({});
+        });
+        it('contains errors when mandatory is not provided', () => {
+            const subject = createSubject(validYaml);
+            withEnvVarsHelper({ TEST_ENV_MANDATORY: '' }, () => subject.validate());
+            expect(subject.parsingError).toEqual(undefined);
+            expect(Object.keys(subject.errors)).toEqual(['TEST_ENV_MANDATORY']);
+        });
+        it('contains errors when boolean is different than true or false', () => {
+            const subject = createSubject(validYaml);
+            withEnvVarsHelper({ TEST_ENV_BOOLEAN1: 'value' }, () => subject.validate());
+            expect(subject.parsingError).toEqual(undefined);
+            expect(Object.keys(subject.errors)).toEqual(['TEST_ENV_BOOLEAN1']);
+        });
+        it('contains errors when enum is different than provided options', () => {
+            const subject = createSubject(validYaml);
+            withEnvVarsHelper({ TEST_ENV_ENUM1: 'option3' }, () => subject.validate());
+            expect(subject.parsingError).toEqual(undefined);
+            expect(Object.keys(subject.errors)).toEqual(['TEST_ENV_ENUM1']);
+        });
+    });
+});
+describe('DotEnvParser', () => {
+    function createSubject(text) {
+        const subject = new DotEnvParser('dummy-path.env');
+        vi.spyOn(subject, '_readFile').mockReturnValue(text);
+        return subject;
+    }
+    it('works, taking into account comments and ignoring empty lines', () => {
+        const subject = createSubject(`
+        
+    # Ignored
+    TEST1=hello
+
+    TEST2=world   # also ignored
+
+
+    TEST3 = spaces should not normally be allowed in .env   # so the parser is not strict
+
+    `);
+        subject.parse();
+        expect(subject.keys).toEqual(['TEST1', 'TEST2', 'TEST3']);
+    });
+});
+describe('CombinedEnvValidator', () => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    function createSubject(yamlContent, dotEnvContent) {
+        const yamlPaths = yamlContent.map((_, i) => `dummy-yaml-${i}`);
+        const dotEnvPaths = dotEnvContent.map((_, i) => `dummy-dotenv-${i}`);
+        const yamlValidators = yamlContent.map((content, i) => {
+            const validator = new SingleEnvValidator(yamlPaths[i]);
+            vi.spyOn(validator, '_readFile').mockReturnValue(content);
+            return validator;
+        });
+        const dotEnvParsers = dotEnvContent.map((content, i) => {
+            const parser = new DotEnvParser(dotEnvPaths[i]);
+            vi.spyOn(parser, '_readFile').mockReturnValue(content);
+            return parser;
+        });
+        const subject = new CombinedEnvValidator(yamlPaths, dotEnvPaths);
+        vi.spyOn(subject, '_loadYamlFiles').mockImplementation(() => (subject.yamlValidators = yamlValidators));
+        vi.spyOn(subject, '_loadDotEnvFiles').mockImplementation(() => (subject.dotEnvParsers = dotEnvParsers));
+        return subject;
+    }
+    it('works when no errors and no warnings', () => {
+        const yaml1 = ['TEST_ENV1', 'TEST_ENV2'];
+        const yaml2 = [{ TEST_ENV3: 'optional' }];
+        const dotEnv1 = 'TEST_ENV1=hi';
+        const dotEnv2 = 'TEST_ENV2=bye';
+        const subject = createSubject([yaml1, yaml2], [dotEnv1, dotEnv2]);
+        withEnvVars({ TEST_ENV1: 'hi', TEST_ENV2: 'bye' }, () => subject.validate());
+        expect(subject.warnings).toEqual([]);
+        expect(subject.errors).toEqual({});
+    });
+    it('emits warnings', () => {
+        const yaml1 = ['TEST_ENV1', 'TEST_ENV2'];
+        const yaml2 = [{ TEST_ENV3: 'optional' }];
+        const dotEnv1 = 'TEST_ENV1=hi';
+        const dotEnv2 = 'TEST_ENV2=bye';
+        const dotEnv3 = 'TEST_ENV4=boo';
+        const subject = createSubject([yaml1, yaml2], [dotEnv1, dotEnv2, dotEnv3]);
+        withEnvVars({ TEST_ENV1: 'hi', TEST_ENV2: 'bye' }, () => subject.validate());
+        expect(subject.warnings.length).toEqual(1);
+        expect(subject.warnings[0]).toContain('TEST_ENV4');
+        expect(subject.errors).toEqual({});
+    });
+    it('emits errors', () => {
+        vi.spyOn(process, 'exit').mockReturnValue(undefined);
+        const yaml1 = ['TEST_ENV1', 'TEST_ENV2'];
+        const yaml2 = [{ TEST_ENV3: 'optional' }];
+        const dotEnv1 = 'TEST_ENV1=hi';
+        const subject = createSubject([yaml1, yaml2], [dotEnv1]);
+        withEnvVars({ TEST_ENV1: 'hi' }, () => subject.validate());
+        expect(process.exit).toHaveBeenCalledWith(1);
+        expect(subject.warnings).toEqual([]);
+        expect(Object.keys(subject.errors)).toEqual(['TEST_ENV2']);
+    });
+});

package/dist/libs/workspace-discovery.d.ts

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

package/dist/libs/workspace-discovery.d.ts.map

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

package/dist/libs/workspace-discovery.js

@@ -0,0 +1,75 @@
+// import chalk from "chalk";
+// import fs from "fs";
+// import { globSync } from "glob";
+// import path from "path";
+// import type { PkgData, ProjectData } from "../types";
+// import { WorkspaceDependencies } from "./dependencies";
+// import { getImageData, getImageNames } from "./config";
+export {};
+// const _imageDescendents: Record<string, string[]> = {};
+// let _imageDescendentsLoaded = false;
+// function imageDescendents() {
+//   if (!_imageDescendentsLoaded) {
+//     for (const imageName of getImageNames()) {
+//       const imageData = getImageData(imageName);
+//       const descendents = new Set<string>();
+//       imageData.applications.forEach((project) => {
+//         descendents.add(project);
+//         getDescendentNames(project).forEach((name) => descendents.add(name));
+//       });
+//       _imageDescendents[imageName] = Array.from(descendents);
+//     }
+//     _imageDescendentsLoaded = true;
+//   }
+//   return _imageDescendents;
+// }
+// const _workspaceImages: Record<string, string[]> = {};
+// let _workspaceImagesLoaded = false;
+// function workspaceImages() {
+//   if (!_workspaceImagesLoaded) {
+//     for (const [imageName, descendents] of Object.entries(imageDescendents())) {
+//       for (const workspaceName of descendents) {
+//         _workspaceImages[workspaceName] ??= [];
+//         _workspaceImages[workspaceName].push(imageName);
+//       }
+//     }
+//     _workspaceImagesLoaded = true;
+//   }
+//   return _workspaceImages;
+// }
+// export function workspaceNames() {
+//   return Object.keys(workspaces());
+// }
+// export function getWorkspace(workspaceName: string) {
+//   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;
+// }
+// const dependencyResolve = new WorkspaceDependencies(workspaces);
+// /** Note: this includes the name of the provided workspace */
+// export function getDescendentNames(workspaceName: string) {
+//   const _ensurePresence = getWorkspace(workspaceName);
+//   return dependencyResolve.getDependents(workspaceName);
+// }
+// /** Note: this includes the provided workspace's data */
+// export function getDecendentData(workspaceName: string) {
+//   return getDescendentNames(workspaceName).map((name) => getWorkspace(name));
+// }
+// /** The dependent workspaces are specified in config/images.yaml */
+// export function getImageDescendentNames(imageName: string) {
+//   return imageDescendents()[imageName];
+// }
+// /** The dependent workspaces are specified in config/images.yaml */
+// export function getImageDescendentData(imageName: string) {
+//   return (
+//     getImageDescendentNames(imageName).map((name) => getWorkspace(name)) ?? []
+//   );
+// }
+// export function getWorkspaceImages(workspaceName: string) {
+//   const _verifyPresence = getWorkspace(workspaceName);
+//   return workspaceImages()[workspaceName] ?? [];
+// }

package/dist/test.d.ts

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

package/dist/test.d.ts.map

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

package/dist/test.js

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