cdk8s-cli 2.0.123 → 2.1.0

package/.projenrc.ts

@@ -14,6 +14,9 @@ const project = new typescript.TypeScriptProject({
   authorUrl: 'https://aws.amazon.com',
   minNodeVersion: '14.17.0',
 
+  // no need, we are configuring explicit exports.
+  entrypoint: '',
+
   keywords: [
     'k8s',
     'cdk8s',
@@ -53,11 +56,14 @@ const project = new typescript.TypeScriptProject({
     'json2jsii',
     'colors',
     'ajv',
+    'table',
+    'semver',
   ],
   devDeps: [
     '@cdk8s/projen-common',
     '@types/fs-extra@^8',
     '@types/json-schema',
+    '@types/semver',
     'glob',
     '@types/glob',
     'typescript-json-schema',
@@ -80,6 +86,14 @@ const project = new typescript.TypeScriptProject({
   },
 });
 
+//
+// see https://nodejs.org/api/packages.html#exports
+project.addFields({
+  exports: {
+    './plugins': './lib/plugins/index.js',
+  },
+});
+
 // ignore integration tests since they need to executed after packaging
 // and are defined in a separate tasks.
 project.jest?.addIgnorePattern('/test/integ/');
@@ -91,7 +105,7 @@ new Cdk8sCommon(project);
 // add @types/node as a regular dependency since it's needed to during "import"
 // to compile the generated jsii code.
 project.deps.removeDependency('@types/node', DependencyType.BUILD);
-project.deps.addDependency('@types/node@^12', DependencyType.RUNTIME);
+project.deps.addDependency('@types/node@^14', DependencyType.RUNTIME);
 
 const schemas = project.addTask('schemas');
 schemas.exec('ts-node scripts/crd.schema.ts');

package/lib/cli/cmds/synth.js

@@ -23,9 +23,10 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const path = __importStar(require("path"));
-const fs = __importStar(require("fs-extra"));
+const fs = __importStar(require("fs"));
+const yaml = __importStar(require("yaml"));
 const config_1 = require("../../config");
+const _manager_1 = require("../../plugins/_manager");
 const util_1 = require("../../util");
 const config = (0, config_1.readConfigSync)();
 class Command {
@@ -36,29 +37,55 @@ class Command {
         this.builder = (args) => args
             .option('app', { default: config.app, required: true, desc: 'Command to use in order to execute cdk8s app', alias: 'a' })
             .option('output', { default: config.output, required: false, desc: 'Output directory', alias: 'o' })
-            .option('stdout', { type: 'boolean', required: false, desc: 'Write synthesized manifests to STDOUT instead of the output directory', alias: 'p' });
+            .option('stdout', { type: 'boolean', required: false, desc: 'Write synthesized manifests to STDOUT instead of the output directory', alias: 'p' })
+            .option('plugins-dir', { default: config.pluginsDirectory, required: false, desc: 'Directory to store cdk8s plugins.' })
+            .option('validate', { type: 'boolean', default: true, required: false, desc: 'Apply validation plugins on the resulting manifests (use --no-validate to disable)' })
+            .option('validation-reports-output-file', { required: false, desc: 'File to write a JSON representation of the validation reports to' });
     }
+    ;
     async handler(argv) {
         const command = argv.app;
         const outdir = argv.output;
         const stdout = argv.stdout;
-        if (outdir !== config.output && stdout) {
+        const validate = argv.validate;
+        const pluginsDir = argv.pluginsDir;
+        const reportFile = argv.validationReportsOutputFile;
+        if (outdir && outdir !== config.output && stdout) {
             throw new Error('\'--output\' and \'--stdout\' are mutually exclusive. Please only use one.');
         }
-        await fs.remove(outdir);
+        if (outdir) {
+            fs.rmSync(outdir, { recursive: true, force: true });
+        }
+        const validations = validate ? await fetchValidations() : undefined;
         if (stdout) {
             await (0, util_1.mkdtemp)(async (tempDir) => {
-                await (0, util_1.synthApp)(command, tempDir);
-                const manifests = (await fs.readdir(tempDir)).filter(f => path.extname(f) === '.yaml');
-                for (const f of manifests) {
-                    fs.createReadStream(path.join(tempDir, f)).pipe(process.stdout);
+                const app = await (0, util_1.synthApp)(command, tempDir, stdout, validate);
+                for (const f of app.manifests) {
+                    fs.createReadStream(f).pipe(process.stdout);
+                }
+                if (validations) {
+                    const pluginManager = new _manager_1.PluginManager(pluginsDir);
+                    await (0, util_1.validateApp)(app, stdout, validations, pluginManager, reportFile);
                 }
             });
         }
         else {
-            await (0, util_1.synthApp)(command, outdir);
+            const manifests = await (0, util_1.synthApp)(command, outdir, stdout, validate);
+            if (validations) {
+                const pluginManager = new _manager_1.PluginManager(pluginsDir);
+                await (0, util_1.validateApp)(manifests, stdout, validations, pluginManager, reportFile);
+            }
         }
     }
 }
+async function fetchValidations() {
+    if (typeof (config.validations) === 'string') {
+        const content = await (0, util_1.download)(config.validations);
+        return yaml.parse(content);
+    }
+    else {
+        return config.validations;
+    }
+}
 module.exports = new Command();
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/config.d.ts

@@ -3,10 +3,23 @@ export interface ImportSpec {
     readonly moduleNamePrefix?: string;
     readonly source: string;
 }
+export interface ValidationConfig {
+    readonly package: string;
+    readonly version: string;
+    readonly class: string;
+    readonly installEnv?: {
+        [key: string]: any;
+    };
+    readonly properties?: {
+        [key: string]: any;
+    };
+}
 export interface Config {
     readonly app?: string;
     readonly language?: Language;
     readonly output?: string;
     readonly imports?: string[];
+    readonly pluginsDirectory?: string;
+    readonly validations?: string | ValidationConfig[];
 }
 export declare function readConfigSync(): Config;

package/lib/config.js

@@ -24,11 +24,14 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.readConfigSync = void 0;
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
 const fs = __importStar(require("fs-extra"));
 const yaml = __importStar(require("yaml"));
 const CONFIG_FILE = 'cdk8s.yaml';
 const DEFAULTS = {
     output: 'dist',
+    pluginsDirectory: path.join(os.homedir(), '.cdk8s', 'plugins'),
 };
 function readConfigSync() {
     let config = DEFAULTS;
@@ -41,4 +44,4 @@ function readConfigSync() {
     return config;
 }
 exports.readConfigSync = readConfigSync;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlnLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2NvbmZpZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLDZDQUErQjtBQUMvQiwyQ0FBNkI7QUFHN0IsTUFBTSxXQUFXLEdBQUcsWUFBWSxDQUFDO0FBY2pDLE1BQU0sUUFBUSxHQUFXO0lBQ3ZCLE1BQU0sRUFBRSxNQUFNO0NBQ2YsQ0FBQztBQUVGLFNBQWdCLGNBQWM7SUFDNUIsSUFBSSxNQUFNLEdBQVcsUUFBUSxDQUFDO0lBQzlCLElBQUksRUFBRSxDQUFDLFVBQVUsQ0FBQyxXQUFXLENBQUMsRUFBRTtRQUM5QixNQUFNLEdBQUc7WUFDUCxHQUFHLE1BQU07WUFDVCxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsRUFBRSxDQUFDLFlBQVksQ0FBQyxXQUFXLEVBQUUsT0FBTyxDQUFDLENBQUM7U0FDckQsQ0FBQztLQUNIO0lBRUQsT0FBTyxNQUFNLENBQUM7QUFDaEIsQ0FBQztBQVZELHdDQVVDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0ICogYXMgZnMgZnJvbSAnZnMtZXh0cmEnO1xuaW1wb3J0ICogYXMgeWFtbCBmcm9tICd5YW1sJztcbmltcG9ydCB7IExhbmd1YWdlIH0gZnJvbSAnLi9pbXBvcnQvYmFzZSc7XG5cbmNvbnN0IENPTkZJR19GSUxFID0gJ2NkazhzLnlhbWwnO1xuXG5leHBvcnQgaW50ZXJmYWNlIEltcG9ydFNwZWMge1xuICByZWFkb25seSBtb2R1bGVOYW1lUHJlZml4Pzogc3RyaW5nO1xuICByZWFkb25seSBzb3VyY2U6IHN0cmluZztcbn1cblxuZXhwb3J0IGludGVyZmFjZSBDb25maWcge1xuICByZWFkb25seSBhcHA/OiBzdHJpbmc7XG4gIHJlYWRvbmx5IGxhbmd1YWdlPzogTGFuZ3VhZ2U7XG4gIHJlYWRvbmx5IG91dHB1dD86IHN0cmluZztcbiAgcmVhZG9ubHkgaW1wb3J0cz86IHN0cmluZ1tdO1xufVxuXG5jb25zdCBERUZBVUxUUzogQ29uZmlnID0ge1xuICBvdXRwdXQ6ICdkaXN0Jyxcbn07XG5cbmV4cG9ydCBmdW5jdGlvbiByZWFkQ29uZmlnU3luYygpOiBDb25maWcge1xuICBsZXQgY29uZmlnOiBDb25maWcgPSBERUZBVUxUUztcbiAgaWYgKGZzLmV4aXN0c1N5bmMoQ09ORklHX0ZJTEUpKSB7XG4gICAgY29uZmlnID0ge1xuICAgICAgLi4uY29uZmlnLFxuICAgICAgLi4ueWFtbC5wYXJzZShmcy5yZWFkRmlsZVN5bmMoQ09ORklHX0ZJTEUsICd1dGYtOCcpKSxcbiAgICB9O1xuICB9XG5cbiAgcmV0dXJuIGNvbmZpZztcbn0iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/lib/plugins/_manager.d.ts

@@ -0,0 +1,80 @@
+/// <reference types="node" />
+/**
+ * Information about a loaded plugin.
+ */
+export interface Plugin {
+    /**
+     * The instance of the plugin class.
+     */
+    readonly instance: unknown;
+    /**
+     * The plugin class name.
+     */
+    readonly class: string;
+    /**
+     * The plugin package.
+     */
+    readonly package: Package;
+}
+/**
+ * Information about a plugin package.
+ */
+export interface Package {
+    /**
+     * The plugin module.
+     */
+    readonly module: ReturnType<NodeRequire>;
+    /**
+      * The npm package of the plugin.
+      */
+    readonly pkg: string;
+    /**
+      * The version of the plugin.
+      */
+    readonly version: string;
+    /**
+      * The path of the plugin on the local system (after its installed).
+      */
+    readonly path: string;
+}
+/**
+ * Options for loading a plugin.
+ */
+export interface PluginManagerLoadOptions {
+    /**
+     * The plugin package name.
+     */
+    readonly pkg: string;
+    /**
+     * The plugin package version.
+     */
+    readonly version: string;
+    /**
+     * The plugin package class.
+     */
+    readonly class: string;
+    /**
+     * Installation environment (passed on to npm install)
+     */
+    readonly installEnv?: {
+        [key: string]: any;
+    };
+    /**
+     * Plugin instantiation properties.
+     */
+    readonly properties?: {
+        [key: string]: any;
+    };
+}
+/**
+ * A `PluginManager` is responsible for loading (and installing) plugins.
+ */
+export declare class PluginManager {
+    private readonly dir;
+    constructor(dir: string);
+    load(options: PluginManagerLoadOptions): Plugin;
+    private loadPackage;
+    private installPackage;
+    private require;
+    private pluginDir;
+}

package/lib/plugins/_manager.js

@@ -0,0 +1,124 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginManager = void 0;
+const child = __importStar(require("child_process"));
+const path = __importStar(require("path"));
+const url = __importStar(require("url"));
+const fs = __importStar(require("fs-extra"));
+const semver = __importStar(require("semver"));
+const MODULE_NOT_FOUND_ERROR_CODE = 'MODULE_NOT_FOUND'; // TODO is there a known constant we can use here?
+/**
+ * A `PluginManager` is responsible for loading (and installing) plugins.
+ */
+class PluginManager {
+    constructor(dir) {
+        this.dir = dir;
+    }
+    load(options) {
+        var _a, _b;
+        const pkg = this.loadPackage(options.pkg, options.version, (_a = options.installEnv) !== null && _a !== void 0 ? _a : {});
+        const clazz = pkg.module[options.class];
+        if (!clazz) {
+            throw new Error(`Unable to locate class '${options.class}' in package '${options.pkg}@${options.version}'. Are you sure you exported it?`);
+        }
+        return { instance: new clazz((_b = options.properties) !== null && _b !== void 0 ? _b : {}), class: options.class, package: pkg };
+    }
+    loadPackage(pkg, version, installEnv) {
+        if (isRange(version)) {
+            // we forbid version ranges because it might give the false impression we will be installing
+            // the latest version (which we will not because it would mean contacting NPM on every synth)
+            throw new Error(`Unsupported version spec for package ${pkg}: ${version}. Cannot be a range.`);
+        }
+        const proto = url.parse(pkg).protocol;
+        if (proto) {
+            // urls are not supported because they don't provide a name with which we can 'require' the module.
+            // if needed, we can make the loader smarter and enable this, but not for now.
+            throw new Error(`Unsupported package reference: ${pkg}. Can either be an NPM package name, or a local path to a directory`);
+        }
+        const local = path.isAbsolute(pkg)
+            // assume relative paths start with '.' because otherise they
+            // are easily confused with npm package names.
+            || pkg.startsWith(`.${path.sep}`);
+        // local plugins are loaded directly, npm packages are loaded
+        // from the plugins directory.
+        const modulePath = local ? path.resolve(process.cwd(), pkg) : this.pluginDir(pkg, version);
+        const pluginName = local ? modulePath : pkg;
+        try {
+            return this.require(modulePath, version, pluginName);
+        }
+        catch (e) {
+            if (![MODULE_NOT_FOUND_ERROR_CODE].includes(e.code)) {
+                // some unexpected error
+                throw e;
+            }
+            if (local) {
+                // if a local plugin is missing, nothing we can do about it
+                throw e;
+            }
+            // otherwise, we install from npm and re-require.
+            this.installPackage(pkg, version, installEnv);
+            return this.require(modulePath, version, pluginName);
+        }
+    }
+    installPackage(pkg, version, env) {
+        const pluginDir = path.join(this.dir, pkg, version);
+        fs.mkdirpSync(pluginDir);
+        const command = [
+            'npm',
+            'install', `${pkg}@${version}`,
+            '--no-save',
+            '--prefix', pluginDir,
+        ].join(' ');
+        const finalEnv = { ...process.env };
+        for (const [key, value] of Object.entries(env)) {
+            finalEnv[key] = typeof value === 'string' ? key : JSON.stringify(value);
+        }
+        console.log(`Installing validation plugin: ${pkg}@${version} (this may take a while the first time around)`);
+        child.execSync(command, { stdio: ['ignore', 'pipe', 'pipe'], env: finalEnv });
+    }
+    require(spec, version, pluginName) {
+        const modulePath = require.resolve(spec);
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const module = require(modulePath);
+        return { version, pkg: pluginName !== null && pluginName !== void 0 ? pluginName : spec, path: modulePath, module };
+    }
+    pluginDir(pkg, version) {
+        return path.join(this.dir, pkg, version, 'node_modules', pkg);
+    }
+}
+exports.PluginManager = PluginManager;
+/**
+ * Checks if a given version represents a range, or a pinned version.
+ * For example:
+ *
+ *   - '1.x expands to '>=1.0.0 <2.0.0-0'
+ *   - `~1.2' expands to '>=1.2.0 <1.3.0-0'
+ *   - '1.2.3' expands to '1.2.3'
+ */
+function isRange(version) {
+    return new semver.Range(version).range !== version;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"_manager.js","sourceRoot":"","sources":["../../src/plugins/_manager.ts"],"names":[],"mappings":"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","sourcesContent":["import * as child from 'child_process';\nimport * as path from 'path';\nimport * as url from 'url';\nimport * as fs from 'fs-extra';\nimport * as semver from 'semver';\n\nconst MODULE_NOT_FOUND_ERROR_CODE = 'MODULE_NOT_FOUND'; // TODO is there a known constant we can use here?\n\n/**\n * Information about a loaded plugin.\n */\nexport interface Plugin {\n\n  /**\n   * The instance of the plugin class.\n   */\n  readonly instance: unknown;\n\n  /**\n   * The plugin class name.\n   */\n  readonly class: string;\n\n  /**\n   * The plugin package.\n   */\n  readonly package: Package;\n\n}\n\n/**\n * Information about a plugin package.\n */\nexport interface Package {\n\n  /**\n   * The plugin module.\n   */\n  readonly module: ReturnType<NodeRequire>;\n\n  /**\n    * The npm package of the plugin.\n    */\n  readonly pkg: string;\n\n  /**\n    * The version of the plugin.\n    */\n  readonly version: string;\n\n  /**\n    * The path of the plugin on the local system (after its installed).\n    */\n  readonly path: string;\n\n}\n\n/**\n * Options for loading a plugin.\n */\nexport interface PluginManagerLoadOptions {\n\n  /**\n   * The plugin package name.\n   */\n  readonly pkg: string;\n\n  /**\n   * The plugin package version.\n   */\n  readonly version: string;\n\n  /**\n   * The plugin package class.\n   */\n  readonly class: string;\n\n  /**\n   * Installation environment (passed on to npm install)\n   */\n  readonly installEnv?: { [key: string]: any };\n\n  /**\n   * Plugin instantiation properties.\n   */\n  readonly properties?: { [key: string]: any };\n\n}\n\n/**\n * A `PluginManager` is responsible for loading (and installing) plugins.\n */\nexport class PluginManager {\n\n  constructor(private readonly dir: string) {}\n\n  public load(options: PluginManagerLoadOptions): Plugin {\n\n    const pkg = this.loadPackage(options.pkg, options.version, options.installEnv ?? {});\n\n    const clazz = pkg.module[options.class];\n    if (!clazz) {\n      throw new Error(`Unable to locate class '${options.class}' in package '${options.pkg}@${options.version}'. Are you sure you exported it?`);\n    }\n\n    return { instance: new clazz(options.properties ?? {}), class: options.class, package: pkg };\n  }\n\n  private loadPackage(pkg: string, version: string, installEnv: { [key: string]: any }): Package {\n\n    if (isRange(version)) {\n      // we forbid version ranges because it might give the false impression we will be installing\n      // the latest version (which we will not because it would mean contacting NPM on every synth)\n      throw new Error(`Unsupported version spec for package ${pkg}: ${version}. Cannot be a range.`);\n    }\n\n    const proto = url.parse(pkg).protocol;\n\n    if (proto) {\n      // urls are not supported because they don't provide a name with which we can 'require' the module.\n      // if needed, we can make the loader smarter and enable this, but not for now.\n      throw new Error(`Unsupported package reference: ${pkg}. Can either be an NPM package name, or a local path to a directory`);\n    }\n\n    const local = path.isAbsolute(pkg)\n      // assume relative paths start with '.' because otherise they\n      // are easily confused with npm package names.\n      || pkg.startsWith(`.${path.sep}`);\n\n    // local plugins are loaded directly, npm packages are loaded\n    // from the plugins directory.\n    const modulePath = local ? path.resolve(process.cwd(), pkg) : this.pluginDir(pkg, version);\n    const pluginName = local ? modulePath : pkg;\n\n    try {\n      return this.require(modulePath, version, pluginName);\n    } catch (e: any) {\n\n      if (![MODULE_NOT_FOUND_ERROR_CODE].includes(e.code)) {\n        // some unexpected error\n        throw e;\n      }\n\n      if (local) {\n        // if a local plugin is missing, nothing we can do about it\n        throw e;\n      }\n\n      // otherwise, we install from npm and re-require.\n      this.installPackage(pkg, version, installEnv);\n      return this.require(modulePath, version, pluginName);\n    }\n\n  }\n\n  private installPackage(pkg: string, version: string, env: { [key: string]: any }) {\n\n    const pluginDir = path.join(this.dir, pkg, version);\n    fs.mkdirpSync(pluginDir);\n\n    const command = [\n      'npm',\n      'install', `${pkg}@${version}`,\n      '--no-save',\n      '--prefix', pluginDir,\n    ].join(' ');\n\n    const finalEnv = { ...process.env };\n    for (const [key, value] of Object.entries(env)) {\n      finalEnv[key] = typeof value === 'string' ? key : JSON.stringify(value);\n    }\n    console.log(`Installing validation plugin: ${pkg}@${version} (this may take a while the first time around)`);\n    child.execSync(command, { stdio: ['ignore', 'pipe', 'pipe'], env: finalEnv });\n  }\n\n  private require(spec: string, version: string, pluginName: string): Package {\n\n    const modulePath = require.resolve(spec);\n\n    // eslint-disable-next-line @typescript-eslint/no-require-imports\n    const module = require(modulePath);\n\n    return { version, pkg: pluginName ?? spec, path: modulePath, module };\n  }\n\n  private pluginDir(pkg: string, version: string) {\n    return path.join(this.dir, pkg, version, 'node_modules', pkg);\n  }\n\n}\n\n/**\n * Checks if a given version represents a range, or a pinned version.\n * For example:\n *\n *   - '1.x expands to '>=1.0.0 <2.0.0-0'\n *   - `~1.2' expands to '>=1.2.0 <1.3.0-0'\n *   - '1.2.3' expands to '1.2.3'\n */\nfunction isRange(version: string) {\n  return new semver.Range(version).range !== version;\n}"]}

package/lib/plugins/index.d.ts

@@ -0,0 +1 @@
+export { Validation, ValidationContext, ValidationViolation, ValidationViolatingResource } from './validation';

package/lib/plugins/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationContext = void 0;
+var validation_1 = require("./validation");
+Object.defineProperty(exports, "ValidationContext", { enumerable: true, get: function () { return validation_1.ValidationContext; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcGx1Z2lucy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSwyQ0FBK0c7QUFBMUYsK0dBQUEsaUJBQWlCLE9BQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBWYWxpZGF0aW9uLCBWYWxpZGF0aW9uQ29udGV4dCwgVmFsaWRhdGlvblZpb2xhdGlvbiwgVmFsaWRhdGlvblZpb2xhdGluZ1Jlc291cmNlIH0gZnJvbSAnLi92YWxpZGF0aW9uJzsiXX0=

package/lib/plugins/validation.d.ts

@@ -0,0 +1,233 @@
+import { ValidationConfig } from '../config';
+import { SynthesizedApp } from '../util';
+import { PluginManager } from './_manager';
+/**
+ * Context available to plugins during validation.
+ */
+export declare class ValidationContext {
+    /**
+     * The list of manifests to validate.
+     */
+    readonly manifests: readonly string[];
+    /**
+     * The NodeJS package name of the plugin running the validation.
+     */
+    readonly pkg: string;
+    /**
+     * The version of the NodeJS package that runs the validation.
+     */
+    readonly version: string;
+    /**
+     * Construct metadata of resources in the application.
+     */
+    readonly metadata: {
+        readonly [key: string]: ResourceConstructMetadata;
+    };
+    /**
+     * Whether or not the synth command was executed with --stdout.
+     */
+    readonly stdout?: boolean | undefined;
+    /**
+     * Report emitted by the validation.
+     *
+     * Plugins should interact with this object to generate the report.
+     */
+    readonly report: ValidationReport;
+    /**
+     * Logger for the validation.
+     *
+     * Plugins should interact with this object to log messages during validation.
+     */
+    readonly logger: ValidationLogger;
+    constructor(
+    /**
+     * The list of manifests to validate.
+     */
+    manifests: readonly string[], 
+    /**
+     * The NodeJS package name of the plugin running the validation.
+     */
+    pkg: string, 
+    /**
+     * The version of the NodeJS package that runs the validation.
+     */
+    version: string, 
+    /**
+     * Construct metadata of resources in the application.
+     */
+    metadata?: {
+        readonly [key: string]: ResourceConstructMetadata;
+    }, 
+    /**
+     * Whether or not the synth command was executed with --stdout.
+     */
+    stdout?: boolean | undefined);
+    parseManifest(manifestPath: string): any[];
+}
+/**
+ * Logger available to plugins during validation. Use this instead of `console.log`.
+ */
+export declare class ValidationLogger {
+    /**
+     * Log a message.
+     */
+    log(message: string): void;
+}
+/**
+ * Contract between cdk8s and third-parties looking to implement validation plugins.
+ */
+export interface Validation {
+    /**
+     * Run the validation logic.
+     *
+     * - Use `context.manifests` to retrieve the list of manifests to validate.
+     * - Use `context.report` to access and build the resulting report.
+     *
+     * Make sure to call `context.report.pass()` or `context.report.fail()` before returning, otherwise the validation is considered incomplete.
+     */
+    validate(context: ValidationContext): Promise<void>;
+}
+/**
+ * Resource violating a specific rule.
+ */
+export interface ValidationViolatingResource {
+    /**
+     * The resource name.
+     */
+    readonly resourceName: string;
+    /**
+     * The locations in its config that pose the violations.
+     */
+    readonly locations: readonly string[];
+    /**
+     * The manifest this resource is defined in.
+     */
+    readonly manifestPath: string;
+}
+/**
+ * Construct violating a specific rule.
+ */
+export interface ValidationViolatingConstruct extends ValidationViolatingResource {
+    /**
+     * The construct path as defined in the application.
+     */
+    readonly constructPath?: string;
+}
+/**
+ * Violation produced by the validation plugin.
+ */
+export interface ValidationViolation {
+    /**
+     * The name of the rule.
+     */
+    readonly ruleName: string;
+    /**
+     * The recommendation to resolve the violation.
+     */
+    readonly recommendation: string;
+    /**
+     * How to fix the recommendation.
+     */
+    readonly fix: string;
+    /**
+     * The resources violating this rule.
+     */
+    readonly violatingResources: readonly ValidationViolatingResource[];
+}
+/**
+ * Validation produced by the validation plugin, in construct terms.
+ */
+export interface ValidationViolationConstructAware extends Omit<ValidationViolation, 'violatingResources'> {
+    /**
+     * The constructs violating this rule.
+     */
+    readonly violatingConstructs: readonly ValidationViolatingConstruct[];
+}
+export declare type ValidationReportStatus = 'success' | 'failure';
+/**
+ * Summary of the report.
+ */
+export interface ValidationReportSummary {
+    readonly status: ValidationReportStatus;
+    readonly plugin: string;
+    readonly version: string;
+    readonly metadata?: {
+        readonly [key: string]: string;
+    };
+}
+/**
+ * JSON representation of the report.
+ */
+export interface ValidationReportJson {
+    /**
+     * Report title.
+     */
+    readonly title: string;
+    /**
+     * List of violations in the rerpot.
+     */
+    readonly violations: readonly ValidationViolationConstructAware[];
+    /**
+     * Report summary.
+     */
+    readonly summary: ValidationReportSummary;
+}
+/**
+ * The report emitted by the plugin after evaluation.
+ */
+export declare class ValidationReport {
+    private readonly pkg;
+    private readonly version;
+    private readonly metadata;
+    private readonly stdout;
+    private readonly violations;
+    private _summary?;
+    constructor(pkg: string, version: string, metadata: {
+        readonly [key: string]: ResourceConstructMetadata;
+    }, stdout: boolean);
+    /**
+     * Add a violation to the report.
+     */
+    addViolation(violation: ValidationViolation): void;
+    /**
+     * Submit the report with a status and additional metadata.
+     */
+    submit(status: ValidationReportStatus, metadata?: {
+        readonly [key: string]: string;
+    }): void;
+    /**
+     * Whether or not the report was successfull.
+     */
+    get success(): boolean;
+    /**
+     * Transform the report to a well formatted table string.
+     */
+    toString(): string;
+    /**
+     * Transform the report into a JSON object.
+     */
+    toJson(): ValidationReportJson;
+}
+/**
+ * Utiliy class for loading validation plugins.
+ */
+export declare class ValidationPlugin {
+    /**
+     * Load the validation plugin and create the necessary context for its execution.
+     */
+    static load(validation: ValidationConfig, app: SynthesizedApp, stdout: boolean, pluginManager: PluginManager): {
+        plugin: Validation;
+        context: ValidationContext;
+    };
+    private static loadConstructMetadata;
+}
+/**
+ * Construct related metadata on resources.
+ */
+interface ResourceConstructMetadata {
+    /**
+     * The path of the construct in the application.
+     */
+    readonly path: string;
+}
+export {};

package/lib/plugins/validation.js

@@ -0,0 +1,242 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationPlugin = exports.ValidationReport = exports.ValidationLogger = exports.ValidationContext = void 0;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const table_1 = require("table");
+const yaml = __importStar(require("yaml"));
+/**
+ * Context available to plugins during validation.
+ */
+class ValidationContext {
+    constructor(
+    /**
+     * The list of manifests to validate.
+     */
+    manifests, 
+    /**
+     * The NodeJS package name of the plugin running the validation.
+     */
+    pkg, 
+    /**
+     * The version of the NodeJS package that runs the validation.
+     */
+    version, 
+    /**
+     * Construct metadata of resources in the application.
+     */
+    metadata = {}, 
+    /**
+     * Whether or not the synth command was executed with --stdout.
+     */
+    stdout) {
+        var _a;
+        this.manifests = manifests;
+        this.pkg = pkg;
+        this.version = version;
+        this.metadata = metadata;
+        this.stdout = stdout;
+        this.report = new ValidationReport(this.pkg, this.version, (_a = this.metadata) !== null && _a !== void 0 ? _a : {}, stdout !== null && stdout !== void 0 ? stdout : false);
+        this.logger = new ValidationLogger();
+    }
+    parseManifest(manifestPath) {
+        const parsed = yaml.parseAllDocuments(fs.readFileSync(manifestPath, { encoding: 'utf-8' }));
+        const resources = Array.isArray(parsed) ? parsed : [parsed];
+        return resources.map(r => r.toJS());
+    }
+}
+exports.ValidationContext = ValidationContext;
+/**
+ * Logger available to plugins during validation. Use this instead of `console.log`.
+ */
+class ValidationLogger {
+    /**
+     * Log a message.
+     */
+    log(message) {
+        console.log(message);
+    }
+}
+exports.ValidationLogger = ValidationLogger;
+/**
+ * The report emitted by the plugin after evaluation.
+ */
+class ValidationReport {
+    constructor(pkg, version, metadata, stdout) {
+        this.pkg = pkg;
+        this.version = version;
+        this.metadata = metadata;
+        this.stdout = stdout;
+        this.violations = [];
+    }
+    /**
+     * Add a violation to the report.
+     */
+    addViolation(violation) {
+        var _a;
+        if (this._summary) {
+            throw new Error('Violations cannot be added to report after its submitted');
+        }
+        const violatingConstructs = [];
+        for (const resource of violation.violatingResources) {
+            const constructPath = (_a = this.metadata[resource.resourceName]) === null || _a === void 0 ? void 0 : _a.path;
+            violatingConstructs.push({
+                ...resource,
+                // augment with construct metadata
+                constructPath: constructPath,
+                // if synth is executed with --stdout, the manifest path
+                // here is temporary and will be deleted once the command finishes.
+                manifestPath: this.stdout ? 'STDOUT' : resource.manifestPath,
+            });
+        }
+        this.violations.push({
+            ruleName: violation.ruleName,
+            recommendation: violation.recommendation,
+            violatingConstructs: violatingConstructs,
+            fix: violation.fix,
+        });
+    }
+    /**
+     * Submit the report with a status and additional metadata.
+     */
+    submit(status, metadata) {
+        this._summary = { status, plugin: this.pkg, version: this.version, metadata };
+    }
+    /**
+     * Whether or not the report was successfull.
+     */
+    get success() {
+        if (!this._summary) {
+            throw new Error('Unable to determine report status: Report is incomplete. Call \'report.submit\'');
+        }
+        return this._summary.status === 'success';
+    }
+    /**
+     * Transform the report to a well formatted table string.
+     */
+    toString() {
+        var _a, _b;
+        const json = this.toJson();
+        const output = [json.title];
+        output.push('-'.repeat(json.title.length));
+        output.push('');
+        output.push('(Summary)');
+        output.push('');
+        output.push((0, table_1.table)([
+            ['Status', json.summary.status],
+            ['Plugin', json.summary.plugin],
+            ['Version', json.summary.version],
+            ...Object.entries((_a = json.summary.metadata) !== null && _a !== void 0 ? _a : {}),
+        ]));
+        if (json.violations) {
+            output.push('');
+            output.push('(Violations)');
+        }
+        for (const violation of json.violations) {
+            const occurrences = violation.violatingConstructs.flatMap(c => c.locations).length;
+            const title = reset(red(bright(`${violation.ruleName} (${occurrences} occurrences)`)));
+            output.push('');
+            output.push(title);
+            output.push('');
+            output.push('  Occurrences:');
+            for (const construct of violation.violatingConstructs) {
+                output.push('');
+                output.push(`    - Construct Path: ${(_b = construct.constructPath) !== null && _b !== void 0 ? _b : 'N/A'}`);
+                output.push(`    - Manifest Path: ${construct.manifestPath}`);
+                output.push(`    - Resource Name: ${construct.resourceName}`);
+                if (construct.locations) {
+                    output.push('    - Locations:');
+                    for (const location of construct.locations) {
+                        output.push(`      > ${location}`);
+                    }
+                }
+            }
+            output.push('');
+            output.push(`  Recommendation: ${violation.recommendation}`);
+            output.push(`  How to fix: ${violation.fix}`);
+        }
+        return output.join(os.EOL);
+    }
+    /**
+     * Transform the report into a JSON object.
+     */
+    toJson() {
+        if (!this._summary) {
+            throw new Error('Unable to determine report result: Report is incomplete. Call \'report.submit\'');
+        }
+        return {
+            title: `Validation Report (${this.pkg}@${this.version})`,
+            violations: this.violations,
+            summary: this._summary,
+        };
+    }
+}
+exports.ValidationReport = ValidationReport;
+/**
+ * Utiliy class for loading validation plugins.
+ */
+class ValidationPlugin {
+    /**
+     * Load the validation plugin and create the necessary context for its execution.
+     */
+    static load(validation, app, stdout, pluginManager) {
+        const plugin = pluginManager.load({
+            pkg: validation.package,
+            version: validation.version,
+            class: validation.class,
+            properties: validation.properties,
+            installEnv: validation.installEnv,
+        });
+        if (typeof (plugin.instance.validate) !== 'function') {
+            throw new Error(`Instance of class '${validation.class}' from package '${validation.package}@${validation.version}' is not a validation plugin. Are you sure you specified the correct class?`);
+        }
+        const metadata = app.constructMetadata ? this.loadConstructMetadata(app.constructMetadata) : {};
+        const context = new ValidationContext(app.manifests, plugin.package.pkg, plugin.package.version, metadata, stdout);
+        return { plugin: plugin.instance, context };
+    }
+    static loadConstructMetadata(constructMetadataPath) {
+        const contents = JSON.parse(fs.readFileSync(constructMetadataPath, { encoding: 'utf-8' }));
+        const resources = {};
+        if (contents.version !== '1.0.0') {
+            throw new Error(`Unexpected version of construct metadata at ${constructMetadataPath}: ${contents.version}. Supported versions are: [1.0.0]`);
+        }
+        for (const [name, metadata] of Object.entries(contents.resources)) {
+            resources[name] = { path: metadata.path };
+        }
+        return resources;
+    }
+}
+exports.ValidationPlugin = ValidationPlugin;
+function reset(s) {
+    return `${s}\x1b[0m`;
+}
+function red(s) {
+    return `\x1b[31m${s}`;
+}
+function bright(s) {
+    return `\x1b[1m${s}`;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"validation.js","sourceRoot":"","sources":["../../src/plugins/validation.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from 'fs';\nimport * as os from 'os';\nimport { table } from 'table';\nimport * as yaml from 'yaml';\nimport { ValidationConfig } from '../config';\nimport { SynthesizedApp } from '../util';\nimport { PluginManager } from './_manager';\n\n/**\n * Context available to plugins during validation.\n */\nexport class ValidationContext {\n\n  /**\n   * Report emitted by the validation.\n   *\n   * Plugins should interact with this object to generate the report.\n   */\n  public readonly report: ValidationReport;\n\n  /**\n   * Logger for the validation.\n   *\n   * Plugins should interact with this object to log messages during validation.\n   */\n  public readonly logger: ValidationLogger;\n\n  constructor(\n\n    /**\n     * The list of manifests to validate.\n     */\n    public readonly manifests: readonly string[],\n\n    /**\n     * The NodeJS package name of the plugin running the validation.\n     */\n    public readonly pkg: string,\n\n    /**\n     * The version of the NodeJS package that runs the validation.\n     */\n    public readonly version: string,\n\n    /**\n     * Construct metadata of resources in the application.\n     */\n    public readonly metadata: {readonly [key: string]: ResourceConstructMetadata} = {},\n\n    /**\n     * Whether or not the synth command was executed with --stdout.\n     */\n    public readonly stdout?: boolean) {\n\n    this.report = new ValidationReport(this.pkg, this.version, this.metadata ?? {}, stdout ?? false);\n    this.logger = new ValidationLogger();\n  }\n\n  public parseManifest(manifestPath: string): any[] {\n    const parsed = yaml.parseAllDocuments(fs.readFileSync(manifestPath, { encoding: 'utf-8' }));\n    const resources = Array.isArray(parsed) ? parsed : [parsed];\n    return resources.map(r => r.toJS());\n  }\n}\n\n/**\n * Logger available to plugins during validation. Use this instead of `console.log`.\n */\nexport class ValidationLogger {\n\n  /**\n   * Log a message.\n   */\n  public log(message: string) {\n    console.log(message);\n  }\n}\n\n/**\n * Contract between cdk8s and third-parties looking to implement validation plugins.\n */\nexport interface Validation {\n\n  /**\n   * Run the validation logic.\n   *\n   * - Use `context.manifests` to retrieve the list of manifests to validate.\n   * - Use `context.report` to access and build the resulting report.\n   *\n   * Make sure to call `context.report.pass()` or `context.report.fail()` before returning, otherwise the validation is considered incomplete.\n   */\n  validate(context: ValidationContext): Promise<void>;\n\n}\n\n/**\n * Resource violating a specific rule.\n */\nexport interface ValidationViolatingResource {\n\n  /**\n   * The resource name.\n   */\n  readonly resourceName: string;\n\n  /**\n   * The locations in its config that pose the violations.\n   */\n  readonly locations: readonly string[];\n\n  /**\n   * The manifest this resource is defined in.\n   */\n  readonly manifestPath: string;\n\n}\n\n/**\n * Construct violating a specific rule.\n */\nexport interface ValidationViolatingConstruct extends ValidationViolatingResource {\n\n  /**\n   * The construct path as defined in the application.\n   */\n  readonly constructPath?: string;\n\n}\n\n/**\n * Violation produced by the validation plugin.\n */\nexport interface ValidationViolation {\n\n  /**\n   * The name of the rule.\n   */\n  readonly ruleName: string;\n\n  /**\n   * The recommendation to resolve the violation.\n   */\n  readonly recommendation: string;\n\n  /**\n   * How to fix the recommendation.\n   */\n  readonly fix: string;\n\n  /**\n   * The resources violating this rule.\n   */\n  readonly violatingResources: readonly ValidationViolatingResource[];\n\n}\n\n/**\n * Validation produced by the validation plugin, in construct terms.\n */\nexport interface ValidationViolationConstructAware extends Omit<ValidationViolation, 'violatingResources'> {\n\n  /**\n   * The constructs violating this rule.\n   */\n  readonly violatingConstructs: readonly ValidationViolatingConstruct[];\n}\n\n// we intentionally don't use an enum so that\n// plugins don't have to import the cli at runtime.\nexport type ValidationReportStatus = 'success' | 'failure';\n\n/**\n * Summary of the report.\n */\nexport interface ValidationReportSummary {\n\n  readonly status: ValidationReportStatus;\n\n  readonly plugin: string;\n\n  readonly version: string;\n\n  readonly metadata?: { readonly [key: string]: string };\n\n}\n\n/**\n * JSON representation of the report.\n */\nexport interface ValidationReportJson {\n\n  /**\n   * Report title.\n   */\n  readonly title: string;\n\n  /**\n   * List of violations in the rerpot.\n   */\n  readonly violations: readonly ValidationViolationConstructAware[];\n\n  /**\n   * Report summary.\n   */\n  readonly summary: ValidationReportSummary;\n\n}\n\n/**\n * The report emitted by the plugin after evaluation.\n */\nexport class ValidationReport {\n\n  private readonly violations: ValidationViolationConstructAware[] = [];\n\n  private _summary?: ValidationReportSummary;\n\n  constructor(\n    private readonly pkg: string,\n    private readonly version: string,\n    private readonly metadata: {readonly [key: string]: ResourceConstructMetadata},\n    private readonly stdout: boolean) {\n  }\n\n  /**\n   * Add a violation to the report.\n   */\n  public addViolation(violation: ValidationViolation) {\n    if (this._summary) {\n      throw new Error('Violations cannot be added to report after its submitted');\n    }\n\n    const violatingConstructs: ValidationViolatingConstruct[] = [];\n\n    for (const resource of violation.violatingResources) {\n      const constructPath = this.metadata[resource.resourceName]?.path;\n      violatingConstructs.push({\n        ...resource,\n\n        // augment with construct metadata\n        constructPath: constructPath,\n\n        // if synth is executed with --stdout, the manifest path\n        // here is temporary and will be deleted once the command finishes.\n        manifestPath: this.stdout ? 'STDOUT' : resource.manifestPath,\n      });\n    }\n\n    this.violations.push({\n      ruleName: violation.ruleName,\n      recommendation: violation.recommendation,\n      violatingConstructs: violatingConstructs,\n      fix: violation.fix,\n    });\n  }\n\n  /**\n   * Submit the report with a status and additional metadata.\n   */\n  public submit(status: ValidationReportStatus, metadata?: { readonly [key: string]: string }) {\n    this._summary = { status, plugin: this.pkg, version: this.version, metadata };\n  }\n\n  /**\n   * Whether or not the report was successfull.\n   */\n  public get success(): boolean {\n    if (!this._summary) {\n      throw new Error('Unable to determine report status: Report is incomplete. Call \\'report.submit\\'');\n    }\n    return this._summary.status === 'success';\n  }\n\n  /**\n   * Transform the report to a well formatted table string.\n   */\n  public toString(): string {\n\n    const json = this.toJson();\n    const output = [json.title];\n\n    output.push('-'.repeat(json.title.length));\n    output.push('');\n    output.push('(Summary)');\n    output.push('');\n    output.push(table([\n      ['Status', json.summary.status],\n      ['Plugin', json.summary.plugin],\n      ['Version', json.summary.version],\n      ...Object.entries(json.summary.metadata ?? {}),\n    ]));\n\n    if (json.violations) {\n      output.push('');\n      output.push('(Violations)');\n    }\n    for (const violation of json.violations) {\n      const occurrences = violation.violatingConstructs.flatMap(c => c.locations).length;\n      const title = reset(red(bright(`${violation.ruleName} (${occurrences} occurrences)`)));\n      output.push('');\n      output.push(title);\n      output.push('');\n      output.push('  Occurrences:');\n      for (const construct of violation.violatingConstructs) {\n        output.push('');\n        output.push(`    - Construct Path: ${construct.constructPath ?? 'N/A'}`);\n        output.push(`    - Manifest Path: ${construct.manifestPath}`);\n        output.push(`    - Resource Name: ${construct.resourceName}`);\n        if (construct.locations) {\n          output.push('    - Locations:');\n          for (const location of construct.locations) {\n            output.push(`      > ${location}`);\n          }\n        }\n      }\n      output.push('');\n      output.push(`  Recommendation: ${violation.recommendation}`);\n      output.push(`  How to fix: ${violation.fix}`);\n    }\n\n    return output.join(os.EOL);\n\n  }\n\n  /**\n   * Transform the report into a JSON object.\n   */\n  public toJson(): ValidationReportJson {\n    if (!this._summary) {\n      throw new Error('Unable to determine report result: Report is incomplete. Call \\'report.submit\\'');\n    }\n    return {\n      title: `Validation Report (${this.pkg}@${this.version})`,\n      violations: this.violations,\n      summary: this._summary,\n    };\n  }\n\n}\n\n/**\n * Utiliy class for loading validation plugins.\n */\nexport class ValidationPlugin {\n\n  /**\n   * Load the validation plugin and create the necessary context for its execution.\n   */\n  public static load(\n    validation: ValidationConfig,\n    app: SynthesizedApp,\n    stdout: boolean,\n    pluginManager: PluginManager): { plugin: Validation; context: ValidationContext } {\n\n    const plugin = pluginManager.load({\n      pkg: validation.package,\n      version: validation.version,\n      class: validation.class,\n      properties: validation.properties,\n      installEnv: validation.installEnv,\n    });\n\n    if (typeof((plugin.instance as any).validate) !== 'function') {\n      throw new Error(`Instance of class '${validation.class}' from package '${validation.package}@${validation.version}' is not a validation plugin. Are you sure you specified the correct class?`);\n    }\n\n    const metadata = app.constructMetadata ? this.loadConstructMetadata(app.constructMetadata) : {};\n    const context = new ValidationContext(app.manifests, plugin.package.pkg, plugin.package.version, metadata, stdout);\n    return { plugin: plugin.instance as Validation, context };\n\n  }\n\n  private static loadConstructMetadata(constructMetadataPath: string): { readonly [key: string]: ResourceConstructMetadata } {\n    const contents = JSON.parse(fs.readFileSync(constructMetadataPath, { encoding: 'utf-8' }));\n    const resources: { [key: string]: ResourceConstructMetadata } = {};\n    if (contents.version !== '1.0.0') {\n      throw new Error(`Unexpected version of construct metadata at ${constructMetadataPath}: ${contents.version}. Supported versions are: [1.0.0]`);\n    }\n    for (const [name, metadata] of Object.entries(contents.resources)) {\n      resources[name] = { path: (metadata as any).path };\n    }\n    return resources;\n\n  }\n\n}\n\n/**\n * Construct related metadata on resources.\n */\ninterface ResourceConstructMetadata {\n\n  /**\n   * The path of the construct in the application.\n   */\n  readonly path: string;\n\n}\n\nfunction reset(s: string) {\n  return `${s}\\x1b[0m`;\n}\n\nfunction red(s: string) {\n  return `\\x1b[31m${s}`;\n}\n\nfunction bright(s: string) {\n  return `\\x1b[1m${s}`;\n}"]}

package/lib/util.d.ts

@@ -1,10 +1,27 @@
 /// <reference types="node" />
 import { SpawnOptions } from 'child_process';
+import { ValidationConfig } from './config';
+import { PluginManager } from './plugins/_manager';
 import { SafeReviver } from './reviver';
 export declare function shell(program: string, args?: string[], options?: SpawnOptions): Promise<string>;
 export declare function mkdtemp(closure: (dir: string) => Promise<void>): Promise<void>;
-export declare function synthApp(command: string, outdir: string): Promise<void>;
+export declare function synthApp(command: string, outdir: string, stdout: boolean, metadata: boolean): Promise<SynthesizedApp>;
+export declare function validateApp(app: SynthesizedApp, stdout: boolean, validations: ValidationConfig[], pluginManager: PluginManager, reportsFile?: string): Promise<void>;
 export declare function safeParseJson(text: string, reviver: SafeReviver): any;
 export declare function safeParseYaml(text: string, reviver: SafeReviver): any[];
 export declare function download(url: string): Promise<string>;
-export declare function getFiles(filePath: string): Promise<string[]>;
+export declare function findManifests(directory: string): Promise<string[]>;
+export declare function findConstructMetadata(directory: string): string | undefined;
+/**
+ * Result of synthesizing an application.
+ */
+export interface SynthesizedApp {
+    /**
+     * The list of manifests produced by the app.
+     */
+    readonly manifests: readonly string[];
+    /**
+     * The construct metadata file (if exists).
+     */
+    readonly constructMetadata?: string;
+}

package/lib/util.js

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFiles = exports.download = exports.safeParseYaml = exports.safeParseJson = exports.synthApp = exports.mkdtemp = exports.shell = void 0;
+exports.findConstructMetadata = exports.findManifests = exports.download = exports.safeParseYaml = exports.safeParseJson = exports.validateApp = exports.synthApp = exports.mkdtemp = exports.shell = void 0;
 const child_process_1 = require("child_process");
 const fs_1 = require("fs");
 const http = __importStar(require("http"));
@@ -33,6 +33,7 @@ const path = __importStar(require("path"));
 const url_1 = require("url");
 const fs = __importStar(require("fs-extra"));
 const yaml = __importStar(require("yaml"));
+const validation_1 = require("./plugins/validation");
 async function shell(program, args = [], options = {}) {
     var _a;
     const command = `"${program} ${args.join(' ')}" at ${path.resolve((_a = options.cwd) !== null && _a !== void 0 ? _a : '.')}`;
@@ -63,12 +64,17 @@ async function mkdtemp(closure) {
     }
 }
 exports.mkdtemp = mkdtemp;
-async function synthApp(command, outdir) {
+async function synthApp(command, outdir, stdout, metadata) {
+    var _a;
+    console.log('Synthesizing application');
     await shell(command, [], {
         shell: true,
         env: {
             ...process.env,
             CDK8S_OUTDIR: outdir,
+            // record metadata so that the validation report
+            // has contruct aware context.
+            CDK8S_RECORD_CONSTRUCT_METADATA: (_a = process.env.CDK8S_RECORD_CONSTRUCT_METADATA) !== null && _a !== void 0 ? _a : (metadata ? 'true' : 'false'),
         },
     });
     if (!await fs.pathExists(outdir)) {
@@ -76,18 +82,62 @@ async function synthApp(command, outdir) {
         process.exit(1);
     }
     let found = false;
-    const yamlFiles = await getFiles(outdir);
+    const yamlFiles = await findManifests(outdir);
     if (yamlFiles === null || yamlFiles === void 0 ? void 0 : yamlFiles.length) {
-        for (const yamlFile of yamlFiles) {
-            console.log(yamlFile);
+        if (!stdout) {
+            for (const yamlFile of yamlFiles) {
+                console.log(`  - ${yamlFile}`);
+            }
         }
         found = true;
     }
     if (!found) {
         console.error('No manifests synthesized');
     }
+    const constructMetadata = findConstructMetadata(outdir);
+    return { manifests: yamlFiles, constructMetadata };
 }
 exports.synthApp = synthApp;
+async function validateApp(app, stdout, validations, pluginManager, reportsFile) {
+    const validators = [];
+    for (const validation of validations) {
+        const { plugin, context } = validation_1.ValidationPlugin.load(validation, app, stdout, pluginManager);
+        validators.push({ plugin, context });
+    }
+    const reports = [];
+    let success = true;
+    console.log('Performing validations');
+    for (const validator of validators) {
+        await validator.plugin.validate(validator.context);
+        const report = validator.context.report;
+        success = success && report.success;
+        reports.push(report);
+    }
+    console.log('Validations finished');
+    // now we can print them. we don't incrementally print
+    // so to not clutter the terminal in case of errors.
+    for (const report of reports) {
+        console.log('');
+        console.log(report.toString());
+        console.log('');
+    }
+    if (reportsFile) {
+        if (fs.existsSync(reportsFile)) {
+            throw new Error(`Unable to write validation reports file. Already exists: ${reportsFile}`);
+        }
+        // write the reports in JSON to a file
+        fs.writeFileSync(reportsFile, JSON.stringify({
+            reports: reports.map(r => r.toJson()),
+        }, null, 2));
+    }
+    // exit with failure if any report resulted in a failure
+    if (!success) {
+        console.error('Validation failed. See above reports for details');
+        process.exit(2);
+    }
+    console.log('Validations ended succesfully');
+}
+exports.validateApp = validateApp;
 function safeParseJson(text, reviver) {
     const json = JSON.parse(text);
     reviver.sanitize(json);
@@ -151,26 +201,32 @@ async function download(url) {
     });
 }
 exports.download = download;
-async function getFiles(filePath) {
+async function findManifests(directory) {
     // Ensure path is valid
     try {
-        await fs_1.promises.access(filePath);
+        await fs_1.promises.access(directory);
     }
     catch {
         return [];
     }
     // Read Path contents
-    const entries = await fs_1.promises.readdir(filePath, { withFileTypes: true });
+    const entries = await fs_1.promises.readdir(directory, { withFileTypes: true });
     // Get files within the current directory
     const files = entries
-        .filter(file => (!file.isDirectory() && file.name.endsWith('.k8s.yaml')))
-        .map(file => (filePath + '/' + file.name));
+        .filter(file => (!file.isDirectory() && file.name.endsWith('.yaml')))
+        .map(file => (directory + '/' + file.name));
     // Get sub-folders within the current folder
     const folders = entries.filter(folder => folder.isDirectory());
     for (const folder of folders) {
-        files.push(...await getFiles(`${filePath}/${folder.name}`));
+        files.push(...await findManifests(`${directory}/${folder.name}`));
     }
     return files;
 }
-exports.getFiles = getFiles;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"util.js","sourceRoot":"","sources":["../src/util.ts"],"names":[],"mappings":"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","sourcesContent":["import { spawn, SpawnOptions } from 'child_process';\nimport { promises } from 'fs';\nimport * as http from 'http';\nimport * as https from 'https';\nimport * as os from 'os';\nimport * as path from 'path';\nimport { parse } from 'url';\nimport * as fs from 'fs-extra';\nimport * as yaml from 'yaml';\nimport { SafeReviver } from './reviver';\n\nexport async function shell(program: string, args: string[] = [], options: SpawnOptions = { }): Promise<string> {\n  const command = `\"${program} ${args.join(' ')}\" at ${path.resolve(options.cwd ?? '.')}`;\n  return new Promise((ok, ko) => {\n    const child = spawn(program, args, { stdio: ['inherit', 'pipe', 'inherit'], ...options });\n    const data = new Array<Buffer>();\n    child.stdout?.on('data', chunk => data.push(chunk));\n\n    child.once('error', err => ko(new Error(`command ${command} failed: ${err}`)));\n    child.once('exit', code => {\n      if (code === 0) {\n        return ok(Buffer.concat(data).toString('utf-8'));\n      } else {\n        return ko(new Error(`command ${command} returned a non-zero exit code ${code}`));\n      }\n    });\n  });\n}\n\nexport async function mkdtemp(closure: (dir: string) => Promise<void>) {\n  const workdir = await fs.mkdtemp(path.join(os.tmpdir(), 'cdk8s-'));\n  try {\n    await closure(workdir);\n  } finally {\n    await fs.remove(workdir);\n  }\n}\n\nexport async function synthApp(command: string, outdir: string) {\n  await shell(command, [], {\n    shell: true,\n    env: {\n      ...process.env,\n      CDK8S_OUTDIR: outdir,\n    },\n  });\n\n  if (!await fs.pathExists(outdir)) {\n    console.error(`ERROR: synthesis failed, app expected to create \"${outdir}\"`);\n    process.exit(1);\n  }\n\n  let found = false;\n  const yamlFiles = await getFiles(outdir);\n  if (yamlFiles?.length) {\n    for (const yamlFile of yamlFiles) {\n      console.log(yamlFile);\n    }\n    found = true;\n  }\n\n  if (!found) {\n    console.error('No manifests synthesized');\n  }\n}\n\nexport function safeParseJson(text: string, reviver: SafeReviver): any {\n  const json = JSON.parse(text);\n  reviver.sanitize(json);\n  return json;\n}\n\nexport function safeParseYaml(text: string, reviver: SafeReviver): any[] {\n\n  // parseAllDocuments doesnt accept a reviver\n  // so we first parse normally and than transform\n  // to JS using the reviver.\n  const parsed = yaml.parseAllDocuments(text);\n  const docs = [];\n  for (const doc of parsed) {\n    const json = doc.toJS();\n    reviver.sanitize(json);\n    docs.push(json);\n  }\n  return docs;\n}\n\nexport async function download(url: string): Promise<string> {\n  let client: typeof http | typeof https;\n  const proto = parse(url).protocol;\n\n  if (!proto || proto === 'file:') {\n    return fs.readFile(url, 'utf-8');\n  }\n\n  switch (proto) {\n    case 'https:':\n      client = https;\n      break;\n\n    case 'http:':\n      client = http;\n      break;\n\n    default:\n      throw new Error(`unsupported protocol ${proto}`);\n  }\n\n  return new Promise((ok, ko) => {\n    const req = client.get(url, res => {\n      switch (res.statusCode) {\n        case 200: {\n          const data = new Array<Buffer>();\n          res.on('data', chunk => data.push(chunk));\n          res.once('end', () => ok(Buffer.concat(data).toString('utf-8')));\n          res.once('error', ko);\n          break;\n        }\n\n        case 301:\n        case 302: {\n          if (res.headers.location) {\n            ok(download(res.headers.location));\n          }\n          break;\n        }\n\n        default: {\n          ko(new Error(`${res.statusMessage}: ${url}`));\n        }\n      }\n    });\n\n    req.once('error', ko);\n    req.end();\n  });\n}\n\nexport async function getFiles(filePath: string): Promise<string[]> {\n  // Ensure path is valid\n  try {\n    await promises.access(filePath);\n  } catch {\n    return [];\n  }\n\n  // Read Path contents\n  const entries = await promises.readdir(filePath, { withFileTypes: true });\n\n  // Get files within the current directory\n  const files = entries\n    .filter(file => (!file.isDirectory() && file.name.endsWith('.k8s.yaml')))\n    .map(file => (filePath + '/' + file.name));\n\n  // Get sub-folders within the current folder\n  const folders = entries.filter(folder => folder.isDirectory());\n\n  for (const folder of folders) {\n    files.push(...await getFiles(`${filePath}/${folder.name}`));\n  }\n\n  return files;\n}"]}
+exports.findManifests = findManifests;
+function findConstructMetadata(directory) {
+    // this file is optionally created during synthesis
+    const p = path.join(directory, 'construct-metadata.json');
+    return fs.existsSync(p) ? p : undefined;
+}
+exports.findConstructMetadata = findConstructMetadata;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"util.js","sourceRoot":"","sources":["../src/util.ts"],"names":[],"mappings":"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","sourcesContent":["import { spawn, SpawnOptions } from 'child_process';\nimport { promises } from 'fs';\nimport * as http from 'http';\nimport * as https from 'https';\nimport * as os from 'os';\nimport * as path from 'path';\nimport { parse } from 'url';\nimport * as fs from 'fs-extra';\nimport * as yaml from 'yaml';\nimport { ValidationConfig } from './config';\nimport { PluginManager } from './plugins/_manager';\nimport { ValidationPlugin, ValidationContext, ValidationReport, Validation } from './plugins/validation';\nimport { SafeReviver } from './reviver';\n\nexport async function shell(program: string, args: string[] = [], options: SpawnOptions = { }): Promise<string> {\n  const command = `\"${program} ${args.join(' ')}\" at ${path.resolve(options.cwd ?? '.')}`;\n  return new Promise((ok, ko) => {\n    const child = spawn(program, args, { stdio: ['inherit', 'pipe', 'inherit'], ...options });\n    const data = new Array<Buffer>();\n    child.stdout?.on('data', chunk => data.push(chunk));\n\n    child.once('error', err => ko(new Error(`command ${command} failed: ${err}`)));\n    child.once('exit', code => {\n      if (code === 0) {\n        return ok(Buffer.concat(data).toString('utf-8'));\n      } else {\n        return ko(new Error(`command ${command} returned a non-zero exit code ${code}`));\n      }\n    });\n  });\n}\n\nexport async function mkdtemp(closure: (dir: string) => Promise<void>) {\n  const workdir = await fs.mkdtemp(path.join(os.tmpdir(), 'cdk8s-'));\n  try {\n    await closure(workdir);\n  } finally {\n    await fs.remove(workdir);\n  }\n}\n\nexport async function synthApp(command: string, outdir: string, stdout: boolean, metadata: boolean): Promise<SynthesizedApp> {\n  console.log('Synthesizing application');\n  await shell(command, [], {\n    shell: true,\n    env: {\n      ...process.env,\n      CDK8S_OUTDIR: outdir,\n      // record metadata so that the validation report\n      // has contruct aware context.\n      CDK8S_RECORD_CONSTRUCT_METADATA: process.env.CDK8S_RECORD_CONSTRUCT_METADATA ?? (metadata ? 'true' : 'false'),\n    },\n  });\n\n  if (!await fs.pathExists(outdir)) {\n    console.error(`ERROR: synthesis failed, app expected to create \"${outdir}\"`);\n    process.exit(1);\n  }\n\n  let found = false;\n  const yamlFiles = await findManifests(outdir);\n  if (yamlFiles?.length) {\n    if (!stdout) {\n      for (const yamlFile of yamlFiles) {\n        console.log(`  - ${yamlFile}`);\n      }\n    }\n    found = true;\n  }\n\n  if (!found) {\n    console.error('No manifests synthesized');\n  }\n\n  const constructMetadata = findConstructMetadata(outdir);\n\n  return { manifests: yamlFiles, constructMetadata };\n}\n\nexport async function validateApp(\n  app: SynthesizedApp,\n  stdout: boolean,\n  validations: ValidationConfig[],\n  pluginManager: PluginManager,\n  reportsFile?: string) {\n\n  const validators: { plugin: Validation; context: ValidationContext}[] = [];\n\n  for (const validation of validations) {\n    const { plugin, context } = ValidationPlugin.load(validation, app, stdout, pluginManager);\n    validators.push({ plugin, context });\n  }\n\n  const reports: ValidationReport[] = [];\n  let success = true;\n\n  console.log('Performing validations');\n\n  for (const validator of validators) {\n    await validator.plugin.validate(validator.context);\n    const report = validator.context.report;\n    success = success && report.success;\n    reports.push(report);\n  }\n\n  console.log('Validations finished');\n\n  // now we can print them. we don't incrementally print\n  // so to not clutter the terminal in case of errors.\n  for (const report of reports) {\n    console.log('');\n    console.log(report.toString());\n    console.log('');\n  }\n\n  if (reportsFile) {\n\n    if (fs.existsSync(reportsFile)) {\n      throw new Error(`Unable to write validation reports file. Already exists: ${reportsFile}`);\n    }\n    // write the reports in JSON to a file\n    fs.writeFileSync(reportsFile, JSON.stringify({\n      reports: reports.map(r => r.toJson()),\n    }, null, 2));\n  }\n\n  // exit with failure if any report resulted in a failure\n  if (!success) {\n    console.error('Validation failed. See above reports for details');\n    process.exit(2);\n  }\n\n  console.log('Validations ended succesfully');\n\n}\n\nexport function safeParseJson(text: string, reviver: SafeReviver): any {\n  const json = JSON.parse(text);\n  reviver.sanitize(json);\n  return json;\n}\n\nexport function safeParseYaml(text: string, reviver: SafeReviver): any[] {\n\n  // parseAllDocuments doesnt accept a reviver\n  // so we first parse normally and than transform\n  // to JS using the reviver.\n  const parsed = yaml.parseAllDocuments(text);\n  const docs = [];\n  for (const doc of parsed) {\n    const json = doc.toJS();\n    reviver.sanitize(json);\n    docs.push(json);\n  }\n  return docs;\n}\n\nexport async function download(url: string): Promise<string> {\n\n  let client: typeof http | typeof https;\n  const proto = parse(url).protocol;\n\n  if (!proto || proto === 'file:') {\n    return fs.readFile(url, 'utf-8');\n  }\n\n  switch (proto) {\n    case 'https:':\n      client = https;\n      break;\n\n    case 'http:':\n      client = http;\n      break;\n\n    default:\n      throw new Error(`unsupported protocol ${proto}`);\n  }\n\n  return new Promise((ok, ko) => {\n    const req = client.get(url, res => {\n      switch (res.statusCode) {\n        case 200: {\n          const data = new Array<Buffer>();\n          res.on('data', chunk => data.push(chunk));\n          res.once('end', () => ok(Buffer.concat(data).toString('utf-8')));\n          res.once('error', ko);\n          break;\n        }\n\n        case 301:\n        case 302: {\n          if (res.headers.location) {\n            ok(download(res.headers.location));\n          }\n          break;\n        }\n\n        default: {\n          ko(new Error(`${res.statusMessage}: ${url}`));\n        }\n      }\n    });\n\n    req.once('error', ko);\n    req.end();\n  });\n}\n\nexport async function findManifests(directory: string): Promise<string[]> {\n  // Ensure path is valid\n  try {\n    await promises.access(directory);\n  } catch {\n    return [];\n  }\n\n  // Read Path contents\n  const entries = await promises.readdir(directory, { withFileTypes: true });\n\n  // Get files within the current directory\n  const files = entries\n    .filter(file => (!file.isDirectory() && file.name.endsWith('.yaml')))\n    .map(file => (directory + '/' + file.name));\n\n  // Get sub-folders within the current folder\n  const folders = entries.filter(folder => folder.isDirectory());\n\n  for (const folder of folders) {\n    files.push(...await findManifests(`${directory}/${folder.name}`));\n  }\n\n  return files;\n}\n\nexport function findConstructMetadata(directory: string): string | undefined {\n  // this file is optionally created during synthesis\n  const p = path.join(directory, 'construct-metadata.json');\n  return fs.existsSync(p) ? p : undefined;\n}\n\n/**\n * Result of synthesizing an application.\n */\nexport interface SynthesizedApp {\n\n  /**\n   * The list of manifests produced by the app.\n   */\n  readonly manifests: readonly string[];\n\n  /**\n   * The construct metadata file (if exists).\n   */\n  readonly constructMetadata?: string;\n}"]}

package/package.json

@@ -41,11 +41,12 @@
     "organization": false
   },
   "devDependencies": {
-    "@cdk8s/projen-common": "^0.0.101",
+    "@cdk8s/projen-common": "^0.0.102",
     "@types/fs-extra": "^8",
     "@types/glob": "^7.2.0",
     "@types/jest": "^26.0.24",
     "@types/json-schema": "^7.0.11",
+    "@types/semver": "^7.3.12",
     "@typescript-eslint/eslint-plugin": "^5",
     "@typescript-eslint/parser": "^5",
     "eslint": "^8",
@@ -57,7 +58,7 @@
     "jest-junit": "^13",
     "json-schema": "^0.4.0",
     "npm-check-updates": "^15",
-    "projen": "^0.62.25",
+    "projen": "^0.62.26",
     "standard-version": "^9",
     "ts-jest": "^27",
     "ts-node": "^10.9.1",
@@ -65,18 +66,20 @@
     "typescript-json-schema": "^0.54.0"
   },
   "dependencies": {
-    "@types/node": "^12",
+    "@types/node": "^14",
     "ajv": "^8.11.0",
-    "cdk8s": "^2.5.2",
-    "cdk8s-plus-22": "^2.0.0-rc.132",
+    "cdk8s": "^2.5.3",
+    "cdk8s-plus-22": "^2.0.0-rc.134",
     "codemaker": "^1.69.0",
     "colors": "1.4.0",
-    "constructs": "^10.1.116",
+    "constructs": "^10.1.117",
     "fs-extra": "^8",
     "jsii-pacmak": "^1.69.0",
-    "jsii-srcmak": "^0.1.689",
-    "json2jsii": "^0.3.136",
+    "jsii-srcmak": "^0.1.690",
+    "json2jsii": "^0.3.137",
+    "semver": "^7.3.7",
     "sscaff": "^1.2.274",
+    "table": "^6.8.0",
     "yaml": "2.0.0-11",
     "yargs": "^15"
   },
@@ -92,9 +95,8 @@
   "engines": {
     "node": ">= 14.17.0"
   },
-  "main": "lib/index.js",
   "license": "Apache-2.0",
-  "version": "2.0.123",
+  "version": "2.1.0",
   "jest": {
     "testMatch": [
       "<rootDir>/src/**/__tests__/**/*.ts?(x)",
@@ -137,7 +139,9 @@
       }
     }
   },
-  "types": "lib/index.d.ts",
+  "exports": {
+    "./plugins": "./lib/plugins/index.js"
+  },
   "resolutions": {
     "@types/responselike": "1.0.0",
     "got": "12.3.1"