@aws-cdk/cloud-assembly-schema - npm Package Compare versions

Comparing version 1.46.0 to 1.47.0

lib/index.d.ts

@@ -0,5 +1,3 @@
+export * from './cloud-assembly';
+export * from './assets';
 export * from './manifest';
-export * from './schema';
-export * from './metadata-schema';
-export * from './artifact-schema';
-export * from './context-queries';

lib/index.js

@@ -13,7 +13,5 @@ "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./cloud-assembly"), exports);
+__exportStar(require("./assets"), exports);
 __exportStar(require("./manifest"), exports);
-__exportStar(require("./schema"), exports);
-__exportStar(require("./metadata-schema"), exports);
-__exportStar(require("./artifact-schema"), exports);
-__exportStar(require("./context-queries"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7QUFBQSw2Q0FBMkI7QUFDM0IsMkNBQXlCO0FBQ3pCLG9EQUFrQztBQUNsQyxvREFBa0M7QUFDbEMsb0RBQWtDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9tYW5pZmVzdCc7XG5leHBvcnQgKiBmcm9tICcuL3NjaGVtYSc7XG5leHBvcnQgKiBmcm9tICcuL21ldGFkYXRhLXNjaGVtYSc7XG5leHBvcnQgKiBmcm9tICcuL2FydGlmYWN0LXNjaGVtYSc7XG5leHBvcnQgKiBmcm9tICcuL2NvbnRleHQtcXVlcmllcyc7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7QUFBQSxtREFBaUM7QUFDakMsMkNBQXlCO0FBQ3pCLDZDQUEyQiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vY2xvdWQtYXNzZW1ibHknO1xuZXhwb3J0ICogZnJvbSAnLi9hc3NldHMnO1xuZXhwb3J0ICogZnJvbSAnLi9tYW5pZmVzdCc7XG4iXX0=

lib/manifest.d.ts

@@ -1,2 +0,3 @@
-import * as assembly from './schema';
+import * as assets from './assets';
+import * as assembly from './cloud-assembly';
 export declare const VERSION_MISMATCH: string;
@@ -8,19 +9,44 @@ /**
     /**
-     * Save manifest to file.
+     * Validates and saves the cloud assembly manifest to file.
      *
      * @param manifest - manifest.
+     * @param filePath - output file path.
      */
-    static save(manifest: assembly.AssemblyManifest, filePath: string): void;
+    static saveAssemblyManifest(manifest: assembly.AssemblyManifest, filePath: string): void;
     /**
-     * Load manifest from file.
+     * Load and validates the cloud assembly manifest from file.
      *
      * @param filePath - path to the manifest file.
      */
-    static load(filePath: string): assembly.AssemblyManifest;
+    static loadAssemblyManifest(filePath: string): assembly.AssemblyManifest;
     /**
+     * Validates and saves the asset manifest to file.
+     *
+     * @param manifest - manifest.
+     * @param filePath - output file path.
+     */
+    static saveAssetManifest(manifest: assets.AssetManifest, filePath: string): void;
+    /**
+     * Load and validates the asset manifest from file.
+     *
+     * @param filePath - path to the manifest file.
+     */
+    static loadAssetManifest(filePath: string): assets.AssetManifest;
+    /**
      * Fetch the current schema version number.
      */
     static version(): string;
-    private static schema;
+    /**
+     * Deprecated
+     * @deprecated use `saveAssemblyManifest()`
+     */
+    static save(manifest: assembly.AssemblyManifest, filePath: string): void;
+    /**
+     * Deprecated
+     * @deprecated use `loadAssemblyManifest()`
+     */
+    static load(filePath: string): assembly.AssemblyManifest;
     private static validate;
+    private static saveManifest;
+    private static loadManifest;
     /**
@@ -27,0 +53,0 @@ * This requires some explaining...

lib/manifest.js

@@ -7,4 +7,3 @@ "use strict";
 const semver = require("semver");
-const metadata_schema_1 = require("./metadata-schema");
-const assembly = require("./schema");
+const assembly = require("./cloud-assembly");
 // this prefix is used by the CLI to identify this specific error.
@@ -14,34 +13,68 @@ // in which case we want to instruct the user to upgrade his CLI.
 exports.VERSION_MISMATCH = 'Cloud assembly schema version mismatch';
+// tslint:disable: no-var-requires
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const ASSETS_SCHEMA = require('../schema/assets.schema.json');
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const ASSEMBLY_SCHEMA = require('../schema/cloud-assembly.schema.json');
 /**
+ * Version is shared for both manifests
+ */
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const SCHEMA_VERSION = require('../schema/cloud-assembly.version.json').version;
+// tslint:enable: no-var-requires
+/**
  * Protocol utility class.
  */
 class Manifest {
-    constructor() { }
     /**
-     * Save manifest to file.
+     * Validates and saves the cloud assembly manifest to file.
      *
      * @param manifest - manifest.
+     * @param filePath - output file path.
      */
-    static save(manifest, filePath) {
-        fs.writeFileSync(filePath, JSON.stringify(manifest, undefined, 2));
+    static saveAssemblyManifest(manifest, filePath) {
+        Manifest.saveManifest(manifest, filePath, ASSEMBLY_SCHEMA);
     }
     /**
-     * Load manifest from file.
+     * Load and validates the cloud assembly manifest from file.
      *
      * @param filePath - path to the manifest file.
      */
-    static load(filePath) {
-        const raw = JSON.parse(fs.readFileSync(filePath, { encoding: 'utf-8' }));
-        Manifest.patchStackTags(raw);
-        Manifest.validate(raw);
-        return raw;
+    static loadAssemblyManifest(filePath) {
+        return Manifest.loadManifest(filePath, ASSEMBLY_SCHEMA, obj => Manifest.patchStackTags(obj));
     }
     /**
+     * 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 this.loadManifest(filePath, ASSETS_SCHEMA);
+    }
+    /**
      * Fetch the current schema version number.
      */
     static version() {
-        // eslint-disable-next-line @typescript-eslint/no-require-imports
-        return require('../schema/cloud-assembly.version.json').version;
+        return SCHEMA_VERSION;
     }
-    static validate(manifest) {
+    /**
+     * 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) {
         function parseVersion(version) {
@@ -64,3 +97,3 @@ const ver = semver.valid(version);
         const validator = new jsonschema.Validator();
-        const result = validator.validate(manifest, Manifest.schema, {
+        const result = validator.validate(manifest, schema, {
             // does exist but is not in the TypeScript definitions
@@ -74,2 +107,15 @@ nestedErrors: true,
     }
+    static saveManifest(manifest, filePath, schema) {
+        const withVersion = { ...manifest, version: Manifest.version() };
+        Manifest.validate(withVersion, schema);
+        fs.writeFileSync(filePath, JSON.stringify(withVersion, undefined, 2));
+    }
+    static loadManifest(filePath, schema, preprocess) {
+        let obj = JSON.parse(fs.readFileSync(filePath, { encoding: 'utf-8' }));
+        if (preprocess) {
+            obj = preprocess(obj);
+        }
+        Manifest.validate(obj, schema);
+        return obj;
+    }
     /**
@@ -95,7 +141,5 @@ * This requires some explaining...
                     for (const metadataEntry of metadataEntries) {
-                        if (metadataEntry.type === metadata_schema_1.ArtifactMetadataEntryType.STACK_TAGS && metadataEntry.data) {
+                        if (metadataEntry.type === assembly.ArtifactMetadataEntryType.STACK_TAGS && metadataEntry.data) {
                             const metadataAny = metadataEntry;
-                            metadataAny.data = metadataAny.data.map((t) => {
-                                return { key: t.Key, value: t.Value };
-                            });
+                            metadataAny.data = metadataAny.data.map((t) => ({ key: t.Key, value: t.Value }));
                         }
@@ -106,7 +150,7 @@ }
         }
+        return manifest;
     }
+    constructor() { }
 }
 exports.Manifest = Manifest;
-// eslint-disable-next-line @typescript-eslint/no-require-imports
-Manifest.schema = require('../schema/cloud-assembly.schema.json');
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"manifest.js","sourceRoot":"","sources":["manifest.ts"],"names":[],"mappings":";;;AAAA,yBAAyB;AACzB,yCAAyC;AACzC,iCAAiC;AACjC,uDAA8D;AAC9D,qCAAqC;AAErC,kEAAkE;AAClE,iEAAiE;AACjE,6BAA6B;AAChB,QAAA,gBAAgB,GAAW,wCAAwC,CAAC;AAEjF;;GAEG;AACH,MAAa,QAAQ;IAuGnB,gBAAuB,CAAC;IAtGxB;;;;OAIG;IACI,MAAM,CAAC,IAAI,CAAC,QAAmC,EAAE,QAAgB;QACtE,EAAE,CAAC,aAAa,CAAC,QAAQ,EAAE,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC,CAAC;IACrE,CAAC;IAED;;;;OAIG;IACI,MAAM,CAAC,IAAI,CAAC,QAAgB;QACjC,MAAM,GAAG,GAA8B,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,YAAY,CAAC,QAAQ,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC;QACpG,QAAQ,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC;QAC7B,QAAQ,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;QACvB,OAAO,GAAG,CAAC;IACb,CAAC;IAED;;OAEG;IACI,MAAM,CAAC,OAAO;QACnB,iEAAiE;QACjE,OAAO,OAAO,CAAC,uCAAuC,CAAC,CAAC,OAAO,CAAC;IAClE,CAAC;IAKO,MAAM,CAAC,QAAQ,CAAC,QAAmC;QAEzD,SAAS,YAAY,CAAC,OAAe;YACnC,MAAM,GAAG,GAAG,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;YAClC,IAAI,CAAC,GAAG,EAAE;gBACR,MAAM,IAAI,KAAK,CAAC,2BAA2B,OAAO,GAAG,CAAC,CAAC;aACxD;YACD,OAAO,GAAG,CAAC;QACb,CAAC;QAED,MAAM,YAAY,GAAG,YAAY,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC;QACtD,MAAM,MAAM,GAAG,YAAY,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;QAE9C,iDAAiD;QACjD,IAAI,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,YAAY,CAAC,EAAE;YACnC,oFAAoF;YACpF,2CAA2C;YAC3C,MAAM,IAAI,KAAK,CAAC,GAAG,wBAAgB,yCAAyC,YAAY,eAAe,MAAM,EAAE,CAAC,CAAC;SAClH;QAED,mCAAmC;QACnC,MAAM,SAAS,GAAG,IAAI,UAAU,CAAC,SAAS,EAAE,CAAC;QAC7C,MAAM,MAAM,GAAG,SAAS,CAAC,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,MAAM,EAAE;YAE3D,sDAAsD;YACtD,YAAY,EAAE,IAAI;YAElB,sBAAsB,EAAE,KAAK;SAEvB,CAAC,CAAC;QACV,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE;YACjB,MAAM,IAAI,KAAK,CAAC,+BAA+B,MAAM,EAAE,CAAC,CAAC;SAC1D;IAEH,CAAC;IAED;;;;;;;;;;;;;;OAcG;IACK,MAAM,CAAC,cAAc,CAAC,QAAmC;QAC/D,KAAK,MAAM,QAAQ,IAAI,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,SAAS,IAAI,EAAE,CAAC,EAAE;YAC9D,IAAI,QAAQ,CAAC,IAAI,KAAK,QAAQ,CAAC,YAAY,CAAC,wBAAwB,EAAE;gBACpE,KAAK,MAAM,eAAe,IAAI,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,QAAQ,IAAI,EAAE,CAAC,EAAE;oBACpE,KAAK,MAAM,aAAa,IAAI,eAAe,EAAE;wBAC3C,IAAI,aAAa,CAAC,IAAI,KAAK,2CAAyB,CAAC,UAAU,IAAI,aAAa,CAAC,IAAI,EAAE;4BAErF,MAAM,WAAW,GAAG,aAAoB,CAAC;4BAEzC,WAAW,CAAC,IAAI,GAAG,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAM,EAAE,EAAE;gCACjD,OAAO,EAAE,GAAG,EAAE,CAAC,CAAC,GAAG,EAAE,KAAK,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC;4BACxC,CAAC,CAAC,CAAC;yBACJ;qBACF;iBACF;aACF;SACF;IACH,CAAC;;AArGH,4BAyGC;AA3EC,iEAAiE;AAClD,eAAM,GAAsB,OAAO,CAAC,sCAAsC,CAAC,CAAC","sourcesContent":["import * as fs from 'fs';\nimport * as jsonschema from 'jsonschema';\nimport * as semver from 'semver';\nimport { ArtifactMetadataEntryType } from './metadata-schema';\nimport * as assembly from './schema';\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 * Protocol utility class.\n */\nexport class Manifest {\n  /**\n   * Save manifest to file.\n   *\n   * @param manifest - manifest.\n   */\n  public static save(manifest: assembly.AssemblyManifest, filePath: string) {\n    fs.writeFileSync(filePath, JSON.stringify(manifest, undefined, 2));\n  }\n\n  /**\n   * Load manifest from file.\n   *\n   * @param filePath - path to the manifest file.\n   */\n  public static load(filePath: string): assembly.AssemblyManifest {\n    const raw: assembly.AssemblyManifest = JSON.parse(fs.readFileSync(filePath, { encoding: 'utf-8' }));\n    Manifest.patchStackTags(raw);\n    Manifest.validate(raw);\n    return raw;\n  }\n\n  /**\n   * Fetch the current schema version number.\n   */\n  public static version(): string {\n    // eslint-disable-next-line @typescript-eslint/no-require-imports\n    return require('../schema/cloud-assembly.version.json').version;\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-require-imports\n  private static schema: jsonschema.Schema = require('../schema/cloud-assembly.schema.json');\n\n  private static validate(manifest: assembly.AssemblyManifest) {\n\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 = parseVersion(Manifest.version());\n    const actual = parseVersion(manifest.version);\n\n    // first validate the version should be accepted.\n    if (semver.gt(actual, maxSupported)) {\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(`${VERSION_MISMATCH}: Maximum schema version supported is ${maxSupported}, but found ${actual}`);\n    }\n\n    // now validate the format is good.\n    const validator = new jsonschema.Validator();\n    const result = validator.validate(manifest, Manifest.schema, {\n\n      // does exist but is not in the TypeScript definitions\n      nestedErrors: true,\n\n      allowUnknownAttributes: false,\n\n    } as any);\n    if (!result.valid) {\n      throw new Error(`Invalid assembly manifest:\\n${result}`);\n    }\n\n  }\n\n  /**\n   * This requires some explaining...\n   *\n   * We previously used `{ Key, Value }` for the object that represents a stack tag. (Notice the casing)\n   * @link https://github.com/aws/aws-cdk/blob/v1.27.0/packages/aws-cdk/lib/api/cxapp/stacks.ts#L427.\n   *\n   * When that object moved to this package, it had to be JSII compliant, which meant the property\n   * names must be `camelCased`, and not `PascalCased`. This meant it no longer matches the structure in the `manifest.json` file.\n   * In order to support current manifest files, we have to translate the `PascalCased` representation to the new `camelCased` one.\n   *\n   * Note that the serialization itself still writes `PascalCased` because it relates to how CloudFormation expects it.\n   *\n   * Ideally, we would start writing the `camelCased` and translate to how CloudFormation expects it when needed. But this requires nasty\n   * backwards-compatibility code and it just doesn't seem to be worth the effort.\n   */\n  private static patchStackTags(manifest: assembly.AssemblyManifest) {\n    for (const artifact of Object.values(manifest.artifacts || [])) {\n      if (artifact.type === assembly.ArtifactType.AWS_CLOUDFORMATION_STACK) {\n        for (const metadataEntries of Object.values(artifact.metadata || [])) {\n          for (const metadataEntry of metadataEntries) {\n            if (metadataEntry.type === ArtifactMetadataEntryType.STACK_TAGS && metadataEntry.data) {\n\n              const metadataAny = metadataEntry as any;\n\n              metadataAny.data = metadataAny.data.map((t: any) => {\n                return { key: t.Key, value: t.Value };\n              });\n            }\n          }\n        }\n      }\n    }\n  }\n\n  private constructor() {}\n\n}\n"]}
+//# 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 * as assets from './assets';\nimport * as assembly from './cloud-assembly';\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// tslint:disable: no-var-requires\n\n// eslint-disable-next-line @typescript-eslint/no-require-imports\nconst ASSETS_SCHEMA = require('../schema/assets.schema.json');\n\n// eslint-disable-next-line @typescript-eslint/no-require-imports\nconst ASSEMBLY_SCHEMA = require('../schema/cloud-assembly.schema.json');\n\n/**\n * Version is shared for both manifests\n */\n// eslint-disable-next-line @typescript-eslint/no-require-imports\nconst SCHEMA_VERSION = require('../schema/cloud-assembly.version.json').version;\n\n// tslint:enable: no-var-requires\n\n/**\n * Protocol utility class.\n */\nexport 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(filePath: string): assembly.AssemblyManifest {\n    return Manifest.loadManifest(filePath, ASSEMBLY_SCHEMA, obj => Manifest.patchStackTags(obj));\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 this.loadManifest(filePath, ASSETS_SCHEMA);\n  }\n\n  /**\n   * Fetch the current schema version number.\n   */\n  public static version(): string {\n    return SCHEMA_VERSION;\n  }\n\n  /**\n   * Deprecated\n   * @deprecated use `saveAssemblyManifest()`\n   */\n  public static save(manifest: assembly.AssemblyManifest, filePath: string) { return this.saveAssemblyManifest(manifest, filePath); }\n\n  /**\n   * Deprecated\n   * @deprecated use `loadAssemblyManifest()`\n   */\n  public static load(filePath: string): assembly.AssemblyManifest { return this.loadAssemblyManifest(filePath); }\n\n  private static validate(manifest: { version: string }, schema: jsonschema.Schema) {\n\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 = parseVersion(Manifest.version());\n    const actual = parseVersion(manifest.version);\n\n    // first validate the version should be accepted.\n    if (semver.gt(actual, maxSupported)) {\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(`${VERSION_MISMATCH}: Maximum schema version supported is ${maxSupported}, but found ${actual}`);\n    }\n\n    // now validate the format is good.\n    const validator = new jsonschema.Validator();\n    const result = validator.validate(manifest, schema, {\n\n      // does exist but is not in the TypeScript definitions\n      nestedErrors: true,\n\n      allowUnknownAttributes: false,\n\n    } as any);\n    if (!result.valid) {\n      throw new Error(`Invalid assembly manifest:\\n${result}`);\n    }\n\n  }\n\n  private static saveManifest(manifest: any, filePath: string, schema: jsonschema.Schema) {\n    const withVersion = { ...manifest, version: Manifest.version() };\n    Manifest.validate(withVersion, schema);\n    fs.writeFileSync(filePath, JSON.stringify(withVersion, undefined, 2));\n  }\n\n  private static loadManifest(filePath: string, schema: jsonschema.Schema, preprocess?: (obj: any) => any) {\n    let obj = JSON.parse(fs.readFileSync(filePath, { encoding: 'utf-8' }));\n    if (preprocess) {\n      obj = preprocess(obj);\n    }\n    Manifest.validate(obj, schema);\n    return obj;\n  }\n\n  /**\n   * This requires some explaining...\n   *\n   * We previously used `{ Key, Value }` for the object that represents a stack tag. (Notice the casing)\n   * @link https://github.com/aws/aws-cdk/blob/v1.27.0/packages/aws-cdk/lib/api/cxapp/stacks.ts#L427.\n   *\n   * When that object moved to this package, it had to be JSII compliant, which meant the property\n   * names must be `camelCased`, and not `PascalCased`. This meant it no longer matches the structure in the `manifest.json` file.\n   * In order to support current manifest files, we have to translate the `PascalCased` representation to the new `camelCased` one.\n   *\n   * Note that the serialization itself still writes `PascalCased` because it relates to how CloudFormation expects it.\n   *\n   * Ideally, we would start writing the `camelCased` and translate to how CloudFormation expects it when needed. But this requires nasty\n   * backwards-compatibility code and it just doesn't seem to be worth the effort.\n   */\n  private static patchStackTags(manifest: assembly.AssemblyManifest) {\n    for (const artifact of Object.values(manifest.artifacts || [])) {\n      if (artifact.type === assembly.ArtifactType.AWS_CLOUDFORMATION_STACK) {\n        for (const metadataEntries of Object.values(artifact.metadata || [])) {\n          for (const metadataEntry of metadataEntries) {\n            if (metadataEntry.type === assembly.ArtifactMetadataEntryType.STACK_TAGS && metadataEntry.data) {\n              const metadataAny = metadataEntry as any;\n              metadataAny.data = metadataAny.data.map((t: any) => ({ key: t.Key, value: t.Value }));\n            }\n          }\n        }\n      }\n    }\n\n    return manifest;\n  }\n\n  private constructor() {}\n\n}\n"]}

package.json

 {
   "name": "@aws-cdk/cloud-assembly-schema",
-  "version": "1.46.0",
+  "version": "1.47.0",
   "description": "Cloud Assembly Schema",
@@ -52,6 +52,6 @@ "main": "lib/index.js",
     "@types/mock-fs": "^4.10.0",
-    "cdk-build-tools": "1.46.0",
+    "cdk-build-tools": "1.47.0",
     "jest": "^25.5.4",
     "mock-fs": "^4.12.0",
-    "pkglint": "1.46.0",
+    "pkglint": "1.47.0",
     "typescript-json-schema": "^0.42.0"
@@ -58,0 +58,0 @@ },

scripts/update-schema.d.ts

 import * as tjs from 'typescript-json-schema';
-export declare function generate(out: string, shouldBump: boolean): tjs.Definition | null;
+export declare const SCHEMAS: string[];
+export declare function update(): void;
+export declare function bump(): void;
+/**
+ * Generates a schema from typescript types.
+ * @returns JSON schema
+ * @param schemaName the schema to generate
+ * @param shouldBump writes a new version of the schema and bumps the major version
+ */
+export declare function generateSchema(schemaName: string, saveToFile?: boolean): tjs.Definition | null;

scripts/update-schema.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generate = void 0;
+exports.generateSchema = exports.bump = exports.update = exports.SCHEMAS = void 0;
 const fs = require("fs");
@@ -13,13 +13,37 @@ const path = require("path");
 }
+/**
+ * Where schemas are committed.
+ */
+const SCHEMA_DIR = path.resolve(__dirname, '../schema');
+const SCHEMA_DEFINITIONS = {
+    'assets': { rootTypeName: 'AssetManifest' },
+    'cloud-assembly': { rootTypeName: 'AssemblyManifest' },
+};
+exports.SCHEMAS = Object.keys(SCHEMA_DEFINITIONS);
+function update() {
+    for (const s of exports.SCHEMAS) {
+        generateSchema(s);
+    }
+    bump();
+}
+exports.update = update;
 function bump() {
-    const metadataPath = '../schema/cloud-assembly.version.json';
+    const versionFile = path.join(SCHEMA_DIR, 'cloud-assembly.version.json');
     // eslint-disable-next-line @typescript-eslint/no-require-imports
-    const metadata = require(metadataPath);
+    const metadata = require(versionFile);
     const oldVersion = metadata.version;
     const newVersion = semver.inc(oldVersion, 'major');
     log(`Updating schema version: ${oldVersion} -> ${newVersion}`);
-    const out = path.join(__dirname, metadataPath);
-    fs.writeFileSync(out, JSON.stringify({ version: newVersion }));
+    fs.writeFileSync(versionFile, JSON.stringify({ version: newVersion }));
 }
-function generate(out, shouldBump) {
+exports.bump = bump;
+/**
+ * Generates a schema from typescript types.
+ * @returns JSON schema
+ * @param schemaName the schema to generate
+ * @param shouldBump writes a new version of the schema and bumps the major version
+ */
+function generateSchema(schemaName, saveToFile = true) {
+    const spec = SCHEMA_DEFINITIONS[schemaName];
+    const out = saveToFile ? path.join(SCHEMA_DIR, `${schemaName}.schema.json`) : '';
     const settings = {
@@ -35,9 +59,6 @@ required: true,
     };
-    const program = tjs.getProgramFromFiles([path.join(__dirname, '../lib/schema.d.ts')], compilerOptions);
-    const schema = tjs.generateSchema(program, 'AssemblyManifest', settings);
+    const program = tjs.getProgramFromFiles([path.join(__dirname, '../lib/index.d.ts')], compilerOptions);
+    const schema = tjs.generateSchema(program, spec.rootTypeName, settings);
     augmentDescription(schema);
     addAnyMetadataEntry(schema);
-    if (shouldBump) {
-        bump();
-    }
     if (out) {
@@ -49,3 +70,3 @@ log(`Generating schema to ${out}`);
 }
-exports.generate = generate;
+exports.generateSchema = generateSchema;
 /**
@@ -88,4 +109,5 @@ * Remove 'default' from the schema since its generated
 function addAnyMetadataEntry(schema) {
-    schema.definitions.MetadataEntry.properties.data.anyOf.push({ description: 'Free form data.' });
+    var _a;
+    (_a = schema.definitions.MetadataEntry) === null || _a === void 0 ? void 0 : _a.properties.data.anyOf.push({ description: 'Free form data.' });
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"update-schema.js","sourceRoot":"","sources":["update-schema.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from 'fs';\nimport * as path from 'path';\nimport * as semver from 'semver';\n// eslint-disable-next-line import/no-extraneous-dependencies\nimport * as tjs from 'typescript-json-schema';\n\nfunction log(message: string) {\n  // tslint:disable-next-line:no-console\n  console.log(message);\n}\n\n/**\n * Where schemas are committed.\n */\nconst SCHEMA_DIR = path.resolve(__dirname, '../schema');\n\nconst SCHEMA_DEFINITIONS: { [schemaName: string]: { rootTypeName: string } } = {\n  'assets': { rootTypeName: 'AssetManifest' },\n  'cloud-assembly': { rootTypeName: 'AssemblyManifest' },\n};\n\nexport const SCHEMAS = Object.keys(SCHEMA_DEFINITIONS);\n\nexport function update() {\n  for (const s of SCHEMAS) {\n    generateSchema(s);\n  }\n\n  bump();\n}\n\nexport function bump() {\n  const versionFile = path.join(SCHEMA_DIR, 'cloud-assembly.version.json');\n\n  // eslint-disable-next-line @typescript-eslint/no-require-imports\n  const metadata = require(versionFile);\n\n  const oldVersion = metadata.version;\n  const newVersion = semver.inc(oldVersion, 'major');\n\n  log(`Updating schema version: ${oldVersion} -> ${newVersion}`);\n  fs.writeFileSync(versionFile, JSON.stringify({version: newVersion}));\n}\n\n/**\n * Generates a schema from typescript types.\n * @returns JSON schema\n * @param schemaName the schema to generate\n * @param shouldBump writes a new version of the schema and bumps the major version\n */\nexport function generateSchema(schemaName: string, saveToFile: boolean = true) {\n  const spec = SCHEMA_DEFINITIONS[schemaName];\n  const out = saveToFile ? path.join(SCHEMA_DIR, `${schemaName}.schema.json`) : '';\n\n  const settings: Partial<tjs.Args> = {\n    required: true,\n    ref: true,\n    topRef: true,\n    noExtraProps: false,\n    out,\n  };\n\n  const compilerOptions = {\n    strictNullChecks: true,\n  };\n\n  const program = tjs.getProgramFromFiles([ path.join(__dirname, '../lib/index.d.ts') ], compilerOptions);\n  const schema = tjs.generateSchema(program, spec.rootTypeName, settings);\n\n  augmentDescription(schema);\n  addAnyMetadataEntry(schema);\n\n  if (out) {\n    log(`Generating schema to ${out}`);\n    fs.writeFileSync(out, JSON.stringify(schema, null, 4));\n  }\n\n  return schema;\n}\n\n/**\n * Remove 'default' from the schema since its generated\n * from the tsdocs, which are not necessarily actual values,\n * but rather descriptive behavior.\n *\n * To keep this inforamtion in the schema, we append it to the\n * 'description' of the property.\n */\nfunction augmentDescription(schema: any) {\n\n  function _recurse(o: any) {\n    for (const prop in o) {\n\n      if (prop === 'description' && typeof o[prop] === 'string') {\n\n        const description = o[prop];\n        const defaultValue = o.default;\n\n        if (!defaultValue) {\n          // property doesn't have a default value\n          // skip\n          continue;\n        }\n\n        const descriptionWithDefault = `${description} (Default ${defaultValue})`;\n\n        delete o.default;\n        o[prop] = descriptionWithDefault;\n\n      } else if (typeof o[prop] === 'object') {\n        _recurse(o[prop]);\n      }\n    }\n  }\n\n  _recurse(schema);\n\n}\n\n/**\n * Patch the properties of MetadataEntry to allow\n * specifying any free form data. This is needed since source\n * code doesn't allow this in order to enforce stricter jsii\n * compatibility checks.\n */\nfunction addAnyMetadataEntry(schema: any) {\n  schema.definitions.MetadataEntry?.properties.data.anyOf.push({description: 'Free form data.'});\n}\n"]}

test/manifest.test.js

@@ -12,20 +12,2 @@ "use strict";
 }
-function clone(obj) {
-    return JSON.parse(JSON.stringify(obj));
-}
-function removeStringKeys(obj, keys) {
-    function _recurse(o) {
-        for (const prop in o) {
-            if (keys.includes(prop) && typeof o[prop] === 'string') {
-                delete o[prop];
-            }
-            else if (typeof o[prop] === 'object') {
-                _recurse(o[prop]);
-            }
-        }
-    }
-    const cloned = clone(obj);
-    _recurse(cloned);
-    return cloned;
-}
 test('manifest save', () => {
@@ -36,40 +18,25 @@ const outdir = fs.mkdtempSync(path.join(os.tmpdir(), 'schema-tests'));
         version: 'version',
+        runtime: {
+            libraries: { lib1: '1.2.3' },
+        },
     };
-    lib_1.Manifest.save(assemblyManifest, manifestFile);
+    lib_1.Manifest.saveAssemblyManifest(assemblyManifest, manifestFile);
     const saved = JSON.parse(fs.readFileSync(manifestFile, { encoding: 'utf-8' }));
-    expect(saved).toEqual(assemblyManifest);
+    expect(saved).toEqual({
+        ...assemblyManifest,
+        version: lib_1.Manifest.version(),
+    });
 });
-test('if this test fails, run "yarn update-schema"', () => {
-    // when we compare schemas we ignore changes the
-    // description that is generated from the ts docstrings.
-    const docStringFields = [
-        'description',
-    ];
-    // eslint-disable-next-line @typescript-eslint/no-require-imports
-    const schema = require('../scripts/update-schema.js');
-    const expected = removeStringKeys(schema.generate(), docStringFields);
-    // eslint-disable-next-line @typescript-eslint/no-require-imports
-    const actual = removeStringKeys(require('../schema/cloud-assembly.schema.json'), docStringFields);
-    try {
-        expect(actual).toEqual(expected);
-    }
-    catch (err) {
-        // I couldn't for the life of me figure out how to provide additional error message
-        // to jest...any ideas?
-        err.message = `Whoops, Looks like the schema has changed. Did you forget to run 'yarn update-schema'?\n\n${err.message}`;
-        throw err;
-    }
-});
 test('manifest load', () => {
-    const loaded = lib_1.Manifest.load(fixture('only-version'));
+    const loaded = lib_1.Manifest.loadAssemblyManifest(fixture('only-version'));
     expect(loaded).toMatchSnapshot();
 });
 test('manifest load fails for invalid nested property', () => {
-    expect(() => lib_1.Manifest.load(fixture('invalid-nested-property'))).toThrow(/Invalid assembly manifest/);
+    expect(() => lib_1.Manifest.loadAssemblyManifest(fixture('invalid-nested-property'))).toThrow(/Invalid assembly manifest/);
 });
 test('manifest load fails for invalid artifact type', () => {
-    expect(() => lib_1.Manifest.load(fixture('invalid-artifact-type'))).toThrow(/Invalid assembly manifest/);
+    expect(() => lib_1.Manifest.loadAssemblyManifest(fixture('invalid-artifact-type'))).toThrow(/Invalid assembly manifest/);
 });
 test('manifest load fails on higher major version', () => {
-    expect(() => lib_1.Manifest.load(fixture('high-version'))).toThrow(/Cloud assembly schema version mismatch/);
+    expect(() => lib_1.Manifest.loadAssemblyManifest(fixture('high-version'))).toThrow(/Cloud assembly schema version mismatch/);
 });
@@ -87,4 +54,5 @@ // once we start introducing minor version bumps that are considered
         };
-        lib_1.Manifest.save(assemblyManifest, manifestFile);
-        expect(() => lib_1.Manifest.load(manifestFile)).toThrow(/Cloud assembly schema version mismatch/);
+        // can't use saveAssemblyManifest because it will force the correct version
+        fs.writeFileSync(manifestFile, JSON.stringify(assemblyManifest));
+        expect(() => lib_1.Manifest.loadAssemblyManifest(manifestFile)).toThrow(/Cloud assembly schema version mismatch/);
     }
@@ -103,11 +71,12 @@ });
         };
-        lib_1.Manifest.save(assemblyManifest, manifestFile);
-        expect(() => lib_1.Manifest.load(manifestFile)).toThrow(/Cloud assembly schema version mismatch/);
+        // can't use saveAssemblyManifest because it will force the correct version
+        fs.writeFileSync(manifestFile, JSON.stringify(assemblyManifest));
+        expect(() => lib_1.Manifest.loadAssemblyManifest(manifestFile)).toThrow(/Cloud assembly schema version mismatch/);
     }
 });
 test('manifest load fails on invalid version', () => {
-    expect(() => lib_1.Manifest.load(fixture('invalid-version'))).toThrow(/Invalid semver string/);
+    expect(() => lib_1.Manifest.loadAssemblyManifest(fixture('invalid-version'))).toThrow(/Invalid semver string/);
 });
 test('manifest load succeeds on unknown properties', () => {
-    const manifest = lib_1.Manifest.load(fixture('unknown-property'));
+    const manifest = lib_1.Manifest.loadAssemblyManifest(fixture('unknown-property'));
     expect(manifest.version).toEqual('0.0.0');
@@ -117,3 +86,3 @@ });
     var _a, _b, _c;
-    const m = lib_1.Manifest.load(fixture('with-stack-tags'));
+    const m = lib_1.Manifest.loadAssemblyManifest(fixture('with-stack-tags'));
     if ((_c = (_b = (_a = m.artifacts) === null || _a === void 0 ? void 0 : _a.stack) === null || _b === void 0 ? void 0 : _b.metadata) === null || _c === void 0 ? void 0 : _c.AwsCdkPlaygroundBatch[0].data) {
@@ -128,3 +97,3 @@ const entry = m.artifacts.stack.metadata.AwsCdkPlaygroundBatch[0].data;
     var _a, _b, _c, _d, _e, _f;
-    const loaded = lib_1.Manifest.load(fixture('random-metadata'));
+    const loaded = lib_1.Manifest.loadAssemblyManifest(fixture('random-metadata'));
     const randomArray = (_b = (_a = loaded.artifacts) === null || _a === void 0 ? void 0 : _a.stack.metadata) === null || _b === void 0 ? void 0 : _b.AwsCdkPlaygroundBatch[0].data;
@@ -143,2 +112,2 @@ const randomNumber = (_d = (_c = loaded.artifacts) === null || _c === void 0 ? void 0 : _c.stack.metadata) === null || _d === void 0 ? void 0 : _d.AwsCdkPlaygroundBatch[1].data;
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"manifest.test.js","sourceRoot":"","sources":["manifest.test.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from 'fs';\nimport * as os from 'os';\nimport * as path from 'path';\nimport * as semver from 'semver';\nimport { AssemblyManifest, Manifest, StackTagsMetadataEntry } from '../lib';\n\nconst FIXTURES = path.join(__dirname, 'fixtures');\n\nfunction fixture(name: string) {\n  return path.join(FIXTURES, name, 'manifest.json');\n}\n\nfunction clone(obj: any) {\n  return JSON.parse(JSON.stringify(obj));\n}\n\nfunction removeStringKeys(obj: any, keys: string[]) {\n\n  function _recurse(o: any) {\n    for (const prop in o) {\n      if (keys.includes(prop) && typeof o[prop] === 'string') {\n        delete o[prop];\n      } else if (typeof o[prop] === 'object') {\n        _recurse(o[prop]);\n      }\n    }\n  }\n\n  const cloned = clone(obj);\n  _recurse(cloned);\n\n  return cloned;\n\n}\n\ntest('manifest save', () => {\n\n  const outdir = fs.mkdtempSync(path.join(os.tmpdir(), 'schema-tests'));\n  const manifestFile = path.join(outdir, 'manifest.json');\n\n  const assemblyManifest: AssemblyManifest = {\n    version: 'version',\n  };\n\n  Manifest.save(assemblyManifest, manifestFile);\n\n  const saved = JSON.parse(fs.readFileSync(manifestFile, { encoding: 'utf-8' }));\n\n  expect(saved).toEqual(assemblyManifest);\n\n});\n\ntest('if this test fails, run \"yarn update-schema\"', () => {\n\n  // when we compare schemas we ignore changes the\n  // description that is generated from the ts docstrings.\n  const docStringFields = [\n    'description',\n  ];\n\n  // eslint-disable-next-line @typescript-eslint/no-require-imports\n  const schema = require('../scripts/update-schema.js');\n\n  const expected = removeStringKeys(schema.generate(), docStringFields);\n\n  // eslint-disable-next-line @typescript-eslint/no-require-imports\n  const actual = removeStringKeys(require('../schema/cloud-assembly.schema.json'), docStringFields);\n\n  try {\n    expect(actual).toEqual(expected);\n  } catch (err) {\n    // I couldn't for the life of me figure out how to provide additional error message\n    // to jest...any ideas?\n    err.message = `Whoops, Looks like the schema has changed. Did you forget to run 'yarn update-schema'?\\n\\n${err.message}`;\n    throw err;\n  }\n});\n\ntest('manifest load', () => {\n  const loaded = Manifest.load(fixture('only-version'));\n  expect(loaded).toMatchSnapshot();\n});\n\ntest('manifest load fails for invalid nested property', () => {\n  expect(() => Manifest.load(fixture('invalid-nested-property'))).toThrow(/Invalid assembly manifest/);\n});\n\ntest('manifest load fails for invalid artifact type', () => {\n  expect(() => Manifest.load(fixture('invalid-artifact-type'))).toThrow(/Invalid assembly manifest/);\n});\n\ntest('manifest load fails on higher major version', () => {\n  expect(() => Manifest.load(fixture('high-version'))).toThrow(/Cloud assembly schema version mismatch/);\n});\n\n// once we start introducing minor version bumps that are considered\n// non breaking, this test can be removed.\ntest('manifest load fails on higher minor version', () => {\n\n  const outdir = fs.mkdtempSync(path.join(os.tmpdir(), 'schema-tests'));\n  const manifestFile = path.join(outdir, 'manifest.json');\n\n  const newVersion = semver.inc(Manifest.version(), 'minor');\n  expect(newVersion).toBeTruthy();\n\n  if (newVersion) {\n    const assemblyManifest: AssemblyManifest = {\n      version: newVersion,\n    };\n\n    Manifest.save(assemblyManifest, manifestFile);\n\n    expect(() => Manifest.load(manifestFile)).toThrow(/Cloud assembly schema version mismatch/);\n  }\n});\n\n// once we start introducing patch version bumps that are considered\n// non breaking, this test can be removed.\ntest('manifest load fails on higher patch version', () => {\n\n  const outdir = fs.mkdtempSync(path.join(os.tmpdir(), 'schema-tests'));\n  const manifestFile = path.join(outdir, 'manifest.json');\n\n  const newVersion = semver.inc(Manifest.version(), 'patch');\n  expect(newVersion).toBeTruthy();\n\n  if (newVersion) {\n    const assemblyManifest: AssemblyManifest = {\n      version: newVersion,\n    };\n\n    Manifest.save(assemblyManifest, manifestFile);\n\n    expect(() => Manifest.load(manifestFile)).toThrow(/Cloud assembly schema version mismatch/);\n  }\n});\n\ntest('manifest load fails on invalid version', () => {\n  expect(() => Manifest.load(fixture('invalid-version'))).toThrow(/Invalid semver string/);\n});\n\ntest('manifest load succeeds on unknown properties', () => {\n  const manifest = Manifest.load(fixture('unknown-property'));\n  expect(manifest.version).toEqual('0.0.0');\n});\n\ntest('stack-tags are deserialized properly', () => {\n\n  const m: AssemblyManifest = Manifest.load(fixture('with-stack-tags'));\n\n  if (m.artifacts?.stack?.metadata?.AwsCdkPlaygroundBatch[0].data) {\n    const entry = m.artifacts.stack.metadata.AwsCdkPlaygroundBatch[0].data as StackTagsMetadataEntry;\n    expect(entry[0].key).toEqual('hello');\n    expect(entry[0].value).toEqual('world');\n  }\n  expect(m.version).toEqual('0.0.0');\n\n});\n\ntest('can access random metadata', () => {\n\n  const loaded = Manifest.load(fixture('random-metadata'));\n  const randomArray = loaded.artifacts?.stack.metadata?.AwsCdkPlaygroundBatch[0].data;\n  const randomNumber = loaded.artifacts?.stack.metadata?.AwsCdkPlaygroundBatch[1].data;\n  const randomMap = loaded.artifacts?.stack.metadata?.AwsCdkPlaygroundBatch[2].data;\n\n  expect(randomArray).toEqual(['42']);\n  expect(randomNumber).toEqual(42);\n  expect(randomMap).toEqual({\n    key: 'value',\n  });\n\n  expect(randomMap).toBeTruthy();\n\n  if (randomMap) {\n    expect((randomMap as any).key).toEqual('value');\n  }\n\n});\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"manifest.test.js","sourceRoot":"","sources":["manifest.test.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from 'fs';\nimport * as os from 'os';\nimport * as path from 'path';\nimport * as semver from 'semver';\nimport { AssemblyManifest, Manifest, StackTagsMetadataEntry } from '../lib';\n\nconst FIXTURES = path.join(__dirname, 'fixtures');\n\nfunction fixture(name: string) {\n  return path.join(FIXTURES, name, 'manifest.json');\n}\n\ntest('manifest save', () => {\n\n  const outdir = fs.mkdtempSync(path.join(os.tmpdir(), 'schema-tests'));\n  const manifestFile = path.join(outdir, 'manifest.json');\n\n  const assemblyManifest: AssemblyManifest = {\n    version: 'version',\n    runtime: {\n      libraries: { lib1: '1.2.3' },\n    },\n  };\n\n  Manifest.saveAssemblyManifest(assemblyManifest, manifestFile);\n\n  const saved = JSON.parse(fs.readFileSync(manifestFile, { encoding: 'utf-8' }));\n\n  expect(saved).toEqual({\n    ...assemblyManifest,\n    version: Manifest.version(), // version is forced\n  });\n});\n\ntest('manifest load', () => {\n  const loaded = Manifest.loadAssemblyManifest(fixture('only-version'));\n  expect(loaded).toMatchSnapshot();\n});\n\ntest('manifest load fails for invalid nested property', () => {\n  expect(() => Manifest.loadAssemblyManifest(fixture('invalid-nested-property'))).toThrow(/Invalid assembly manifest/);\n});\n\ntest('manifest load fails for invalid artifact type', () => {\n  expect(() => Manifest.loadAssemblyManifest(fixture('invalid-artifact-type'))).toThrow(/Invalid assembly manifest/);\n});\n\ntest('manifest load fails on higher major version', () => {\n  expect(() => Manifest.loadAssemblyManifest(fixture('high-version'))).toThrow(/Cloud assembly schema version mismatch/);\n});\n\n// once we start introducing minor version bumps that are considered\n// non breaking, this test can be removed.\ntest('manifest load fails on higher minor version', () => {\n\n  const outdir = fs.mkdtempSync(path.join(os.tmpdir(), 'schema-tests'));\n  const manifestFile = path.join(outdir, 'manifest.json');\n\n  const newVersion = semver.inc(Manifest.version(), 'minor');\n  expect(newVersion).toBeTruthy();\n\n  if (newVersion) {\n    const assemblyManifest: AssemblyManifest = {\n      version: newVersion,\n    };\n\n    // can't use saveAssemblyManifest because it will force the correct version\n    fs.writeFileSync(manifestFile, JSON.stringify(assemblyManifest));\n\n    expect(() => Manifest.loadAssemblyManifest(manifestFile)).toThrow(/Cloud assembly schema version mismatch/);\n  }\n});\n\n// once we start introducing patch version bumps that are considered\n// non breaking, this test can be removed.\ntest('manifest load fails on higher patch version', () => {\n\n  const outdir = fs.mkdtempSync(path.join(os.tmpdir(), 'schema-tests'));\n  const manifestFile = path.join(outdir, 'manifest.json');\n\n  const newVersion = semver.inc(Manifest.version(), 'patch');\n  expect(newVersion).toBeTruthy();\n\n  if (newVersion) {\n    const assemblyManifest: AssemblyManifest = {\n      version: newVersion,\n    };\n\n    // can't use saveAssemblyManifest because it will force the correct version\n    fs.writeFileSync(manifestFile, JSON.stringify(assemblyManifest));\n\n    expect(() => Manifest.loadAssemblyManifest(manifestFile)).toThrow(/Cloud assembly schema version mismatch/);\n  }\n});\n\ntest('manifest load fails on invalid version', () => {\n  expect(() => Manifest.loadAssemblyManifest(fixture('invalid-version'))).toThrow(/Invalid semver string/);\n});\n\ntest('manifest load succeeds on unknown properties', () => {\n  const manifest = Manifest.loadAssemblyManifest(fixture('unknown-property'));\n  expect(manifest.version).toEqual('0.0.0');\n});\n\ntest('stack-tags are deserialized properly', () => {\n\n  const m: AssemblyManifest = Manifest.loadAssemblyManifest(fixture('with-stack-tags'));\n\n  if (m.artifacts?.stack?.metadata?.AwsCdkPlaygroundBatch[0].data) {\n    const entry = m.artifacts.stack.metadata.AwsCdkPlaygroundBatch[0].data as StackTagsMetadataEntry;\n    expect(entry[0].key).toEqual('hello');\n    expect(entry[0].value).toEqual('world');\n  }\n  expect(m.version).toEqual('0.0.0');\n\n});\n\ntest('can access random metadata', () => {\n\n  const loaded = Manifest.loadAssemblyManifest(fixture('random-metadata'));\n  const randomArray = loaded.artifacts?.stack.metadata?.AwsCdkPlaygroundBatch[0].data;\n  const randomNumber = loaded.artifacts?.stack.metadata?.AwsCdkPlaygroundBatch[1].data;\n  const randomMap = loaded.artifacts?.stack.metadata?.AwsCdkPlaygroundBatch[2].data;\n\n  expect(randomArray).toEqual(['42']);\n  expect(randomNumber).toEqual(42);\n  expect(randomMap).toEqual({\n    key: 'value',\n  });\n\n  expect(randomMap).toBeTruthy();\n\n  if (randomMap) {\n    expect((randomMap as any).key).toEqual('value');\n  }\n\n});\n"]}

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Dynamic require

Supply chain risk

Dynamic require can indicate the package is performing dangerous or unsafe dynamic code execution.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Dynamic require

Supply chain risk

Dynamic require can indicate the package is performing dangerous or unsafe dynamic code execution.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

405398

increased by19.67%

Number of package files

113

increased by17.71%

Lines of code

5744

increased by13.27%

Worsened metrics

Number of low supply chain risk alerts

6

increased by50%

No dependency changes