@vaharoni/devops 1.2.13 → 1.2.14

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

@@ -1,56 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,214 +0,0 @@
-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

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

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

@@ -1 +0,0 @@
-{"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

@@ -1,168 +0,0 @@
-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/plugins.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"plugins.d.ts","sourceRoot":"","sources":["../src/plugins.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAClG,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAMpD,eAAO,MAAM,UAAU,QAAgC,CAAC"}