@aws-cdk/cloud-assembly-schema
Version:
Schema for the protocol between CDK framework and CDK CLI
274 lines • 36.4 kB
JavaScript
;
var _a;
Object.defineProperty(exports, "__esModule", { value: true });
exports.Manifest = exports.VERSION_MISMATCH = void 0;
const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
const fs = require("fs");
const jsonschema = require("jsonschema");
const semver = require("semver");
const assembly = require("./cloud-assembly");
/* eslint-disable @typescript-eslint/no-var-requires */
/* eslint-disable @typescript-eslint/no-require-imports */
// this prefix is used by the CLI to identify this specific error.
// in which case we want to instruct the user to upgrade his CLI.
// see exec.ts#createAssembly
exports.VERSION_MISMATCH = 'Cloud assembly schema version mismatch';
/**
* CLI version is created at build and release time
*
* It needs to be .gitignore'd, otherwise the projen 'no uncommitted
* changes' self-check will fail, which means it needs to be generated
* at build time if it doesn't already exist.
*/
const CLI_VERSION = require("../cli-version.json");
const ASSETS_SCHEMA = require("../schema/assets.schema.json");
const ASSEMBLY_SCHEMA = require("../schema/cloud-assembly.schema.json");
const INTEG_SCHEMA = require("../schema/integ.schema.json");
const VALIDATION_REPORT_SCHEMA = require("../schema/validation-report.schema.json");
/**
* Version is shared for both manifests
*/
const SCHEMA_VERSION = require("../schema/version.json");
/**
* Protocol utility class.
*/
class Manifest {
/**
* Validates and saves the cloud assembly manifest to file.
*
* @param manifest - manifest.
* @param filePath - output file path.
*/
static saveAssemblyManifest(manifest, filePath) {
Manifest.saveManifest(manifest, filePath, ASSEMBLY_SCHEMA);
}
/**
* Load and validates the cloud assembly manifest from file.
*
* @param filePath - path to the manifest file.
*/
static loadAssemblyManifest(filePath, options) {
return Manifest.loadManifest(filePath, ASSEMBLY_SCHEMA, Manifest.patchStackTagsOnRead, options);
}
/**
* Validates and saves the asset manifest to file.
*
* @param manifest - manifest.
* @param filePath - output file path.
*/
static saveAssetManifest(manifest, filePath) {
Manifest.saveManifest(manifest, filePath, ASSETS_SCHEMA);
}
/**
* Load and validates the asset manifest from file.
*
* @param filePath - path to the manifest file.
*/
static loadAssetManifest(filePath) {
return Manifest.loadManifest(filePath, ASSETS_SCHEMA);
}
/**
* Validates and saves the integ manifest to file.
*
* @param manifest - manifest.
* @param filePath - output file path.
*/
static saveIntegManifest(manifest, filePath) {
Manifest.saveManifest(manifest, filePath, INTEG_SCHEMA);
}
/**
* Load and validates the integ manifest from file.
*
* @param filePath - path to the manifest file.
*/
static loadIntegManifest(filePath) {
const manifest = this.loadManifest(filePath, INTEG_SCHEMA);
// Adding typing to `validate()` led to `loadManifest()` to properly infer
// its return type, which indicated that the return type of this
// function may be a lie. I could change the schema to make `testCases`
// optional, but that will bump the major version of this package and I
// don't want to do that. So instead, just make sure `testCases` is always there.
return {
...manifest,
testCases: manifest.testCases ?? [],
};
}
/**
* Load and validate the policy validation report from file.
*
* @param filePath - path to the validation report file.
*/
static loadValidationReport(filePath) {
return Manifest.loadManifest(filePath, VALIDATION_REPORT_SCHEMA);
}
/**
* Fetch the current schema version number.
*/
static version() {
return `${SCHEMA_VERSION.revision}.0.0`;
}
/**
* Return the CLI version that supports this Cloud Assembly Schema version
*/
static cliVersion() {
const version = CLI_VERSION.version;
return version ? version : undefined;
}
/**
* Deprecated
* @deprecated use `saveAssemblyManifest()`
*/
static save(manifest, filePath) {
return this.saveAssemblyManifest(manifest, filePath);
}
/**
* Deprecated
* @deprecated use `loadAssemblyManifest()`
*/
static load(filePath) {
return this.loadAssemblyManifest(filePath);
}
static validate(manifest, schema, options) {
function parseVersion(version) {
const ver = semver.valid(version);
if (!ver) {
throw new Error(`Invalid semver string: "${version}"`);
}
return ver;
}
const maxSupported = semver.major(parseVersion(Manifest.version()));
const actual = parseVersion(manifest.version);
// first validate the version should be accepted. all versions within the same minor version are fine
if (maxSupported < semver.major(actual) && !options?.skipVersionCheck) {
// If we have a more specific error to throw than the generic one below, make sure to add that info.
const cliVersion = manifest.minimumCliVersion;
let cliWarning = '';
if (cliVersion) {
cliWarning = `. You need at least CLI version ${cliVersion} to read this manifest.`;
}
// we use a well known error prefix so that the CLI can identify this specific error
// and print some more context to the user.
throw new Error(`${exports.VERSION_MISMATCH}: Maximum schema version supported is ${maxSupported}.x.x, but found ${actual}${cliWarning}`);
}
if (options?.validateSchema ?? (process.env.TESTING_CDK === '1')) {
// now validate the format is good.
const validator = new jsonschema.Validator();
const result = validator.validate(manifest, schema, {
nestedErrors: true,
allowUnknownAttributes: false,
preValidateProperty: Manifest.validateAssumeRoleAdditionalOptions,
});
let errors = result.errors;
if (options?.skipEnumCheck) {
// Enum validations aren't useful when
errors = stripEnumErrors(errors);
}
if (errors.length > 0) {
throw new Error(`Invalid assembly manifest:\n${errors.map((e) => e.stack).join('\n')}`);
}
}
}
static saveManifest(manifest, filePath, schema, preprocess) {
let withVersion = {
...manifest,
version: Manifest.version(),
minimumCliVersion: Manifest.cliVersion(),
};
Manifest.validate(withVersion, schema);
if (preprocess) {
withVersion = preprocess(withVersion);
}
fs.writeFileSync(filePath, JSON.stringify(withVersion, undefined, 2));
}
static loadManifest(filePath, schema, preprocess, options) {
const contents = fs.readFileSync(filePath, { encoding: 'utf-8' });
let obj;
try {
obj = JSON.parse(contents);
}
catch (e) {
throw new Error(`${e.message}, while parsing ${JSON.stringify(contents)}`);
}
if (preprocess) {
obj = preprocess(obj);
}
Manifest.validate(obj, schema, options);
return obj;
}
/**
* Fix the casing of stack tags entries
*
* At the very beginning of the CDK we used to emit stack tags as an object with
* `{ Key, Value }` keys; this had the "advantage" that we could stick those
* tags directly into the `CreateChangeSet` call.
*
* Then we later on used jsii on the assembly schema and we were forced to type
* the in-memory objects as `{ key, value }` with lowercase letters. Now the
* objects have a different on-disk and in-memory format, and we need to convert
* between them.
*
* For backwards compatibility reasons, we used to convert lowercase in-memory
* to uppercase on-disk variant until very recently. This is now unnecessary,
* since no officially supported CDK tools read the stack tags from the
* metadata; the CLI and toolkit library read stack tags from the artifact
* properties.
*
* So although we don't emit uppercase stack tag objects anymore, we might still read
* manifests that have them. Because the manifest we read must pass JSON Schema
* validation (which expects lowercase tag objects), we have to fix the casing
* of these objects after reading from disk and before validating.
*
* That's what this function does.
*/
static patchStackTagsOnRead(manifest) {
const artifacts = Object.values(manifest.artifacts ?? {})
.filter(artifact => artifact.type === assembly.ArtifactType.AWS_CLOUDFORMATION_STACK);
for (const artifact of artifacts) {
const tagMetadata = Object.values(artifact.metadata ?? {})
.flatMap(x => x)
.filter(entry => entry.type === assembly.ArtifactMetadataEntryType.STACK_TAGS);
for (const entry of tagMetadata) {
const tags = entry.data;
for (const tag of tags ?? []) {
const t = tag;
if ('Key' in t) {
t.key = t.Key;
delete t.Key;
}
if ('Value' in t) {
t.value = t.Value;
delete t.Value;
}
}
}
}
return manifest;
}
/**
* Validates that `assumeRoleAdditionalOptions` doesn't contain nor `ExternalId` neither `RoleArn`, as they
* should have dedicated properties preceding this (e.g `assumeRoleArn` and `assumeRoleExternalId`).
*/
static validateAssumeRoleAdditionalOptions(instance, key, _schema, _options, _ctx) {
if (key !== 'assumeRoleAdditionalOptions') {
// note that this means that if we happen to have a property named like this, but that
// does want to allow 'RoleArn' or 'ExternalId', this code will have to change to consider the full schema path.
// I decided to make this less granular for now on purpose because it fits our needs and avoids having messy
// validation logic due to various schema paths.
return;
}
const assumeRoleOptions = instance[key];
if (assumeRoleOptions?.RoleArn) {
throw new Error(`RoleArn is not allowed inside '${key}'`);
}
if (assumeRoleOptions?.ExternalId) {
throw new Error(`ExternalId is not allowed inside '${key}'`);
}
}
}
exports.Manifest = Manifest;
_a = JSII_RTTI_SYMBOL_1;
Manifest[_a] = { fqn: "@aws-cdk/cloud-assembly-schema.Manifest", version: "53.27.0" };
function stripEnumErrors(errors) {
return errors.filter((e) => typeof e.schema === 'string' || !('enum' in e.schema));
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"manifest.js","sourceRoot":"","sources":["manifest.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from 'fs';\nimport * as jsonschema from 'jsonschema';\nimport * as semver from 'semver';\nimport type * as assets from './assets';\nimport * as assembly from './cloud-assembly';\nimport type * as validation from './cloud-assembly/validation-report-schema';\nimport type * as integ from './integ-tests';\n\n/* eslint-disable @typescript-eslint/no-var-requires */\n/* eslint-disable @typescript-eslint/no-require-imports */\n\n// this prefix is used by the CLI to identify this specific error.\n// in which case we want to instruct the user to upgrade his CLI.\n// see exec.ts#createAssembly\nexport const VERSION_MISMATCH: string = 'Cloud assembly schema version mismatch';\n\n/**\n * CLI version is created at build and release time\n *\n * It needs to be .gitignore'd, otherwise the projen 'no uncommitted\n * changes' self-check will fail, which means it needs to be generated\n * at build time if it doesn't already exist.\n */\nimport CLI_VERSION = require('../cli-version.json');\n\nimport ASSETS_SCHEMA = require('../schema/assets.schema.json');\n\nimport ASSEMBLY_SCHEMA = require('../schema/cloud-assembly.schema.json');\n\nimport INTEG_SCHEMA = require('../schema/integ.schema.json');\n\nimport VALIDATION_REPORT_SCHEMA = require('../schema/validation-report.schema.json');\n\n/**\n * Version is shared for both manifests\n */\nimport SCHEMA_VERSION = require('../schema/version.json');\n\n/**\n * Options for the loadManifest operation\n */\nexport interface LoadManifestOptions {\n  /**\n   * Skip the version check\n   *\n   * This means you may read a newer cloud assembly than the CX API is designed\n   * to support, and your application may not be aware of all features that in use\n   * in the Cloud Assembly.\n   *\n   * @default false\n   */\n  readonly skipVersionCheck?: boolean;\n\n  /**\n   * Skip enum checks\n   *\n   * This means you may read enum values you don't know about yet. Make sure to always\n   * check the values of enums you encounter in the manifest.\n   *\n   * @default false\n   */\n  readonly skipEnumCheck?: boolean;\n\n  /**\n   * Topologically sort all artifacts\n   *\n   * This parameter is only respected by the constructor of `CloudAssembly`. The\n   * property lives here for backwards compatibility reasons.\n   *\n   * @default true\n   */\n  readonly topoSort?: boolean;\n\n  /**\n   * Validate the file according to the declared JSON Schema\n   *\n   * Be aware that JSON Schema validation has a significant performance cost\n   * (about 10x over not validating).\n   *\n   * @default false, unless $TESTING_CDK is set to '1'\n   */\n  readonly validateSchema?: boolean;\n}\n\n/**\n * Protocol utility class.\n */\nexport abstract class Manifest {\n  /**\n   * Validates and saves the cloud assembly manifest to file.\n   *\n   * @param manifest - manifest.\n   * @param filePath - output file path.\n   */\n  public static saveAssemblyManifest(manifest: assembly.AssemblyManifest, filePath: string) {\n    Manifest.saveManifest(manifest, filePath, ASSEMBLY_SCHEMA);\n  }\n\n  /**\n   * Load and validates the cloud assembly manifest from file.\n   *\n   * @param filePath - path to the manifest file.\n   */\n  public static loadAssemblyManifest(\n    filePath: string,\n    options?: LoadManifestOptions,\n  ): assembly.AssemblyManifest {\n    return Manifest.loadManifest(filePath, ASSEMBLY_SCHEMA, Manifest.patchStackTagsOnRead, options);\n  }\n\n  /**\n   * Validates and saves the asset manifest to file.\n   *\n   * @param manifest - manifest.\n   * @param filePath - output file path.\n   */\n  public static saveAssetManifest(manifest: assets.AssetManifest, filePath: string) {\n    Manifest.saveManifest(manifest, filePath, ASSETS_SCHEMA);\n  }\n\n  /**\n   * Load and validates the asset manifest from file.\n   *\n   * @param filePath - path to the manifest file.\n   */\n  public static loadAssetManifest(filePath: string): assets.AssetManifest {\n    return Manifest.loadManifest(filePath, ASSETS_SCHEMA);\n  }\n\n  /**\n   * Validates and saves the integ manifest to file.\n   *\n   * @param manifest - manifest.\n   * @param filePath - output file path.\n   */\n  public static saveIntegManifest(manifest: integ.IntegManifest, filePath: string) {\n    Manifest.saveManifest(manifest, filePath, INTEG_SCHEMA);\n  }\n\n  /**\n   * Load and validates the integ manifest from file.\n   *\n   * @param filePath - path to the manifest file.\n   */\n  public static loadIntegManifest(filePath: string): integ.IntegManifest {\n    const manifest = this.loadManifest(filePath, INTEG_SCHEMA);\n\n    // Adding typing to `validate()` led to `loadManifest()` to properly infer\n    // its return type, which indicated that the return type of this\n    // function may be a lie. I could change the schema to make `testCases`\n    // optional, but that will bump the major version of this package and I\n    // don't want to do that. So instead, just make sure `testCases` is always there.\n    return {\n      ...manifest,\n      testCases: (manifest as any).testCases ?? [],\n    };\n  }\n\n  /**\n   * Load and validate the policy validation report from file.\n   *\n   * @param filePath - path to the validation report file.\n   */\n  public static loadValidationReport(filePath: string): validation.PolicyValidationReportJson {\n    return Manifest.loadManifest(filePath, VALIDATION_REPORT_SCHEMA);\n  }\n\n  /**\n   * Fetch the current schema version number.\n   */\n  public static version(): string {\n    return `${SCHEMA_VERSION.revision}.0.0`;\n  }\n\n  /**\n   * Return the CLI version that supports this Cloud Assembly Schema version\n   */\n  public static cliVersion(): string | undefined {\n    const version = CLI_VERSION.version;\n    return version ? version : undefined;\n  }\n\n  /**\n   * Deprecated\n   * @deprecated use `saveAssemblyManifest()`\n   */\n  public static save(manifest: assembly.AssemblyManifest, filePath: string) {\n    return this.saveAssemblyManifest(manifest, filePath);\n  }\n\n  /**\n   * Deprecated\n   * @deprecated use `loadAssemblyManifest()`\n   */\n  public static load(filePath: string): assembly.AssemblyManifest {\n    return this.loadAssemblyManifest(filePath);\n  }\n\n  private static validate(\n    manifest: any,\n    schema: jsonschema.Schema,\n    options?: LoadManifestOptions,\n  ): void {\n    function parseVersion(version: string) {\n      const ver = semver.valid(version);\n      if (!ver) {\n        throw new Error(`Invalid semver string: \"${version}\"`);\n      }\n      return ver;\n    }\n\n    const maxSupported = semver.major(parseVersion(Manifest.version()));\n    const actual = parseVersion(manifest.version);\n\n    // first validate the version should be accepted. all versions within the same minor version are fine\n    if (maxSupported < semver.major(actual) && !options?.skipVersionCheck) {\n      // If we have a more specific error to throw than the generic one below, make sure to add that info.\n      const cliVersion = (manifest as assembly.AssemblyManifest).minimumCliVersion;\n      let cliWarning = '';\n      if (cliVersion) {\n        cliWarning = `. You need at least CLI version ${cliVersion} to read this manifest.`;\n      }\n\n      // we use a well known error prefix so that the CLI can identify this specific error\n      // and print some more context to the user.\n      throw new Error(\n        `${VERSION_MISMATCH}: Maximum schema version supported is ${maxSupported}.x.x, but found ${actual}${cliWarning}`,\n      );\n    }\n\n    if (options?.validateSchema ?? (process.env.TESTING_CDK === '1')) {\n      // now validate the format is good.\n      const validator = new jsonschema.Validator();\n      const result = validator.validate(manifest, schema, {\n        nestedErrors: true,\n        allowUnknownAttributes: false,\n        preValidateProperty: Manifest.validateAssumeRoleAdditionalOptions,\n      });\n\n      let errors = result.errors;\n      if (options?.skipEnumCheck) {\n        // Enum validations aren't useful when\n        errors = stripEnumErrors(errors);\n      }\n      if (errors.length > 0) {\n        throw new Error(`Invalid assembly manifest:\\n${errors.map((e) => e.stack).join('\\n')}`);\n      }\n    }\n  }\n\n  private static saveManifest(\n    manifest: any,\n    filePath: string,\n    schema: jsonschema.Schema,\n    preprocess?: (obj: any) => any,\n  ) {\n    let withVersion = {\n      ...manifest,\n      version: Manifest.version(),\n      minimumCliVersion: Manifest.cliVersion(),\n    } satisfies assembly.AssemblyManifest;\n\n    Manifest.validate(withVersion, schema);\n\n    if (preprocess) {\n      withVersion = preprocess(withVersion);\n    }\n    fs.writeFileSync(filePath, JSON.stringify(withVersion, undefined, 2));\n  }\n\n  private static loadManifest(\n    filePath: string,\n    schema: jsonschema.Schema,\n    preprocess?: (obj: any) => any,\n    options?: LoadManifestOptions,\n  ) {\n    const contents = fs.readFileSync(filePath, { encoding: 'utf-8' });\n    let obj;\n    try {\n      obj = JSON.parse(contents);\n    } catch (e: any) {\n      throw new Error(`${e.message}, while parsing ${JSON.stringify(contents)}`);\n    }\n    if (preprocess) {\n      obj = preprocess(obj);\n    }\n    Manifest.validate(obj, schema, options);\n    return obj;\n  }\n\n  /**\n   * Fix the casing of stack tags entries\n   *\n   * At the very beginning of the CDK we used to emit stack tags as an object with\n   * `{ Key, Value }` keys; this had the \"advantage\" that we could stick those\n   * tags directly into the `CreateChangeSet` call.\n   *\n   * Then we later on used jsii on the assembly schema and we were forced to type\n   * the in-memory objects as `{ key, value }` with lowercase letters. Now the\n   * objects have a different on-disk and in-memory format, and we need to convert\n   * between them.\n   *\n   * For backwards compatibility reasons, we used to convert lowercase in-memory\n   * to uppercase on-disk variant until very recently. This is now unnecessary,\n   * since no officially supported CDK tools read the stack tags from the\n   * metadata; the CLI and toolkit library read stack tags from the artifact\n   * properties.\n   *\n   * So although we don't emit uppercase stack tag objects anymore, we might still read\n   * manifests that have them. Because the manifest we read must pass JSON Schema\n   * validation (which expects lowercase tag objects), we have to fix the casing\n   * of these objects after reading from disk and before validating.\n   *\n   * That's what this function does.\n   */\n  private static patchStackTagsOnRead(this: void, manifest: assembly.AssemblyManifest) {\n    const artifacts = Object.values(manifest.artifacts ?? {})\n      .filter(artifact => artifact.type === assembly.ArtifactType.AWS_CLOUDFORMATION_STACK);\n\n    for (const artifact of artifacts) {\n      const tagMetadata = Object.values(artifact.metadata ?? {})\n        .flatMap(x => x)\n        .filter(entry => entry.type === assembly.ArtifactMetadataEntryType.STACK_TAGS);\n\n      for (const entry of tagMetadata) {\n        const tags = entry.data as unknown as assembly.StackTagsMetadataEntry[] | undefined;\n        for (const tag of tags ?? []) {\n          const t: any = tag;\n          if ('Key' in t) {\n            t.key = t.Key;\n            delete t.Key;\n          }\n          if ('Value' in t) {\n            t.value = t.Value;\n            delete t.Value;\n          }\n        }\n      }\n    }\n\n    return manifest;\n  }\n\n  /**\n   * Validates that `assumeRoleAdditionalOptions` doesn't contain nor `ExternalId` neither `RoleArn`, as they\n   * should have dedicated properties preceding this (e.g `assumeRoleArn` and `assumeRoleExternalId`).\n   */\n  private static validateAssumeRoleAdditionalOptions(\n    this: void,\n    instance: any,\n    key: string,\n    _schema: jsonschema.Schema,\n    _options: jsonschema.Options,\n    _ctx: jsonschema.SchemaContext,\n  ) {\n    if (key !== 'assumeRoleAdditionalOptions') {\n      // note that this means that if we happen to have a property named like this, but that\n      // does want to allow 'RoleArn' or 'ExternalId', this code will have to change to consider the full schema path.\n      // I decided to make this less granular for now on purpose because it fits our needs and avoids having messy\n      // validation logic due to various schema paths.\n      return;\n    }\n\n    const assumeRoleOptions = instance[key];\n    if (assumeRoleOptions?.RoleArn) {\n      throw new Error(`RoleArn is not allowed inside '${key}'`);\n    }\n    if (assumeRoleOptions?.ExternalId) {\n      throw new Error(`ExternalId is not allowed inside '${key}'`);\n    }\n  }\n}\n\nfunction stripEnumErrors(errors: jsonschema.ValidationError[]) {\n  return errors.filter((e) => typeof e.schema === 'string' || !('enum' in e.schema));\n}\n"]}