cdk-common 2.0.30 → 2.0.34

package/node_modules/@aws-cdk/cfnspec/build-tools/validate-cfn.js

@@ -0,0 +1,285 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatErrorInContext = exports.CfnSpecValidator = void 0;
+/* eslint-disable no-console */
+/**
+ * CloudFormation spec validator
+ *
+ * "Why not JSON Schema?", you might ask, and it's a fair question. The answer is:
+ * because the error reporting from JSON schema is pretty bad, and I want the validation
+ * errors reported from this check to be blindingly obvious, as non-spec-experts
+ * are going to have to consume and understand them.
+ *
+ * I tried JSON Schema validation and its errors look like:
+ *
+ * ```
+ * - instance.PropertyTypes["..."].Properties.Xyz does not match allOf schema <#/definitions/Typed> with 7 error[s]:
+ * - instance.PropertyTypes["..."].Properties.Xyz requires property "PrimitiveType"
+ * - instance.PropertyTypes["..."].Properties.Xyz requires property "Type"
+ * - instance.PropertyTypes["..."].Properties.Xyz requires property "Type"
+ * - instance.PropertyTypes["..."].Properties.Xyz requires property "ItemType"
+ * - instance.PropertyTypes["..."].Properties.Xyz requires property "Type"
+ * - instance.PropertyTypes["..."].Properties.Xyz requires property "PrimitiveItemType"
+ * - instance.PropertyTypes["..."].Properties.Xyz is not exactly one from "Primitive","Complex Type","Collection of Primitives","Collection of Complex Types"
+ * ```
+ *
+ * No bueno. In contrast, this script prints:
+ *
+ * ```
+ * {
+ *   "ResourceTypes": {
+ *     "AWS::SageMaker::Device": {
+ *       "Properties": {
+ *         "Device": {
+ *
+ * !!!       must have exactly one of 'Type', 'PrimitiveType', found: {"Type":"Device","PrimitiveType":"Json"} !!!
+ *
+ *           "Documentation": "http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-sagemaker-device.html#cfn-sagemaker-device-device",
+ *           "UpdateType": "Mutable",
+ *           "Required": false,
+ *           "PrimitiveType": "Json",
+ *           "Type": "Device"
+ *         }
+ *       }
+ *     }
+ *   }
+ * }
+ * ```
+ */
+const fs = require("fs-extra");
+class CfnSpecValidator {
+    constructor(spec) {
+        this.errors = new Array();
+        this.root = JsonValue.of(spec);
+    }
+    static validate(spec) {
+        const ret = new CfnSpecValidator(spec);
+        ret.validateSpec();
+        return ret.errors;
+    }
+    validateSpec() {
+        this.assert(this.root.get('PropertyTypes'), isObject, (propTypes) => {
+            this.validateMap(propTypes, (propType) => this.validatePropertyType(propType));
+        });
+        this.assert(this.root.get('ResourceTypes'), isObject, (resTypes) => {
+            this.validateMap(resTypes, (propType) => this.validateResourceType(propType));
+        });
+    }
+    /**
+     * Property types are extremely weird
+     *
+     * Nominally, they define "records" that have a `Properties` field with the defined
+     * properties.
+     *
+     * However, they are also commonly used as aliases for other types, meaning they have
+     * the same type-indicating fields as individual property *fields* would have.
+     *
+     * Also also, it seems to be quite common to have them empty--have no fields at all.
+     * This seems to be taken as an alias for an unstructured `Json` type. It's probably
+     * just a mistake, but unfortunately a mistake that S3 is participating in, so if we
+     * fail on that we won't be able to consume updates to S3's schema. Our codegen is
+     * ready to deal with this and just renders it to an empty struct.
+     */
+    validatePropertyType(propType) {
+        // If the only set of properties is "Documentation", we take this to be an alias
+        // for an empty struct and allow it. I feel icky allowing this, but it seems to
+        // be pragmatic for now.
+        if (Object.keys(propType.value).join(',') === 'Documentation') {
+            return;
+        }
+        const properties = propType.get('Properties');
+        if (properties.hasValue) {
+            this.assert(properties, isObject, (props) => {
+                this.validateProperties(props);
+            });
+        }
+        else {
+            this.validateType(propType, 'if a property type doesn\'t have "Properties", it ');
+        }
+    }
+    validateResourceType(resType) {
+        this.assertOptional(resType.get('Properties'), isObject, (props) => {
+            this.validateProperties(props);
+        });
+        this.assertOptional(resType.get('Attributes'), isObject, (attrs) => {
+            this.validateMap(attrs, attr => {
+                this.validateType(attr);
+            });
+        });
+    }
+    validateProperties(properties) {
+        this.validateMap(properties, prop => {
+            this.validateType(prop);
+            this.assertOptional(prop.get('UpdateType'), (x) => {
+                if (!['Mutable', 'Immutable', 'Conditional'].includes(x)) {
+                    throw new Error(`invalid value for enum: '${x}'`);
+                }
+            });
+        });
+    }
+    /**
+     * Validate the type
+     *
+     * There must be:
+     * - Either Type or PrimitiveType
+     * - Only if Type is List or Map, there will be either an ItemType or a PrimitiveItemType
+     * - Non-primitive Types must correspond to a property type
+     */
+    validateType(typedObject, errorPrefix = '') {
+        const type = typedObject.get('Type');
+        const primitiveType = typedObject.get('PrimitiveType');
+        if (type.hasValue === primitiveType.hasValue) {
+            this.report(typedObject, `${errorPrefix}must have exactly one of 'Type', 'PrimitiveType', found: ${JSON.stringify({
+                Type: type.valueOrUndefined,
+                PrimitiveType: primitiveType.valueOrUndefined,
+            })}`);
+        }
+        this.assertOptional(primitiveType, isValidPrimitive);
+        let isCollectionType = false;
+        const itemType = typedObject.get('ItemType');
+        const primitiveItemType = typedObject.get('PrimitiveItemType');
+        if (type.hasValue) {
+            isCollectionType = COLLECTION_TYPES.includes(type.value);
+            if (isCollectionType) {
+                if (itemType.hasValue === primitiveItemType.hasValue) {
+                    this.report(typedObject, `must have exactly one of 'ItemType', 'PrimitiveItemType', found: ${JSON.stringify({
+                        ItemType: itemType.valueOrUndefined,
+                        PrimitiveItemType: primitiveItemType.valueOrUndefined,
+                    })}`);
+                }
+                this.assertOptional(primitiveItemType, isValidPrimitive);
+                if (itemType.hasValue) {
+                    this.assertValidPropertyTypeReference(itemType);
+                }
+            }
+            else {
+                this.assertValidPropertyTypeReference(type);
+            }
+        }
+        if (!isCollectionType) {
+            if (itemType.hasValue || primitiveItemType.hasValue) {
+                this.report(typedObject, 'only \'List\' or \'Map\' types can have \'ItemType\', \'PrimitiveItemType\'');
+            }
+        }
+        const dupes = typedObject.get('DuplicatesAllowed');
+        if (dupes.hasValue && !isCollectionType) {
+            this.report(dupes, 'occurs on non-collection type');
+        }
+    }
+    assertValidPropertyTypeReference(typeName) {
+        if (BUILTIN_COMPLEX_TYPES.includes(typeName.value)) {
+            return;
+        }
+        const cfnName = typeName.path[1]; // AWS::Xyz::Resource[.Property]
+        const namespace = cfnName.split('.')[0];
+        const propTypeName = `${namespace}.${typeName.value}`;
+        if (!this.root.get('PropertyTypes').get(propTypeName).hasValue) {
+            this.report(typeName, `unknown property type name '${typeName.value}' (missing definition for '${propTypeName}')`);
+        }
+    }
+    assertOptional(x, pred, block) {
+        return x.hasValue ? this.assert(x, pred, block) : true;
+    }
+    assert(x, pred, block) {
+        try {
+            pred(x.value);
+            if (block) {
+                block(new JsonValue(x.value, x.path));
+            }
+            return true;
+        }
+        catch (e) {
+            this.report(x, e.message);
+            return false;
+        }
+    }
+    validateMap(x, block) {
+        for (const key in x.value) {
+            block(x.get(key));
+        }
+    }
+    report(value, message) {
+        this.errors.push({ value, message });
+    }
+}
+exports.CfnSpecValidator = CfnSpecValidator;
+function isObject(x) {
+    if (x == null || typeof x !== 'object' || Array.isArray(x)) {
+        throw new Error(`expected object, found '${x}'`);
+    }
+}
+const COLLECTION_TYPES = ['List', 'Map'];
+const BUILTIN_COMPLEX_TYPES = ['Tag'];
+function isValidPrimitive(x) {
+    const primitives = ['String', 'Long', 'Integer', 'Double', 'Boolean', 'Timestamp', 'Json'];
+    if (!primitives.includes(x)) {
+        throw new Error(`must be one of ${primitives.join(', ')}, got: ${x}`);
+    }
+}
+class JsonValue {
+    constructor(value, path) {
+        this.value = value;
+        this.path = path;
+        this.hasValue = true;
+        this.valueOrUndefined = this.value;
+        this.pathValue = this.value;
+    }
+    static of(x) {
+        return new JsonValue(x, []);
+    }
+    get(k) {
+        if (!this.value || typeof this.value !== 'object' || Array.isArray(this.value)) {
+            return new ErrorValue(`expected object, found ${this.value}`, this.path, this.value);
+        }
+        const ret = this.value[k];
+        if (ret === undefined) {
+            return new ErrorValue(`missing required key '${k}'`, this.path, this.value);
+        }
+        return new JsonValue(ret, [...this.path, `${k}`]);
+    }
+}
+class ErrorValue {
+    constructor(error, path, pathValue) {
+        this.error = error;
+        this.path = path;
+        this.pathValue = pathValue;
+        this.hasValue = false;
+        this.valueOrUndefined = undefined;
+    }
+    get(_k) {
+        return this;
+    }
+    get value() {
+        throw new Error(this.error);
+    }
+}
+function formatErrorInContext(error) {
+    let reportValue = error.value.pathValue;
+    for (let i = error.value.path.length; i > 0; i--) {
+        reportValue = { [error.value.path[i - 1]]: reportValue };
+    }
+    const formattedLines = JSON.stringify(reportValue, undefined, 2).split('\n');
+    const indent = 2 * (error.value.path.length + 1);
+    // Insert the error message at line N with an appropriate indent
+    formattedLines.splice(error.value.path.length + 1, 0, `\n!!!${' '.repeat(indent - 3)}${error.message} !!!\n`);
+    return formattedLines.join('\n');
+}
+exports.formatErrorInContext = formatErrorInContext;
+async function main(args) {
+    const spec = await fs.readJson(args[0]);
+    const errors = CfnSpecValidator.validate(spec);
+    if (errors.length !== 0) {
+        for (const error of errors) {
+            console.error(formatErrorInContext(error));
+        }
+        process.exitCode = 1;
+    }
+}
+if (require.main === module) {
+    main(process.argv.slice(2)).catch(e => {
+        process.exitCode = 1;
+        // eslint-disable-next-line no-console
+        console.error(e.message);
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"validate-cfn.js","sourceRoot":"","sources":["validate-cfn.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable no-console */\n/**\n * CloudFormation spec validator\n *\n * \"Why not JSON Schema?\", you might ask, and it's a fair question. The answer is:\n * because the error reporting from JSON schema is pretty bad, and I want the validation\n * errors reported from this check to be blindingly obvious, as non-spec-experts\n * are going to have to consume and understand them.\n *\n * I tried JSON Schema validation and its errors look like:\n *\n * ```\n * - instance.PropertyTypes[\"...\"].Properties.Xyz does not match allOf schema <#/definitions/Typed> with 7 error[s]:\n * - instance.PropertyTypes[\"...\"].Properties.Xyz requires property \"PrimitiveType\"\n * - instance.PropertyTypes[\"...\"].Properties.Xyz requires property \"Type\"\n * - instance.PropertyTypes[\"...\"].Properties.Xyz requires property \"Type\"\n * - instance.PropertyTypes[\"...\"].Properties.Xyz requires property \"ItemType\"\n * - instance.PropertyTypes[\"...\"].Properties.Xyz requires property \"Type\"\n * - instance.PropertyTypes[\"...\"].Properties.Xyz requires property \"PrimitiveItemType\"\n * - instance.PropertyTypes[\"...\"].Properties.Xyz is not exactly one from \"Primitive\",\"Complex Type\",\"Collection of Primitives\",\"Collection of Complex Types\"\n * ```\n *\n * No bueno. In contrast, this script prints:\n *\n * ```\n * {\n *   \"ResourceTypes\": {\n *     \"AWS::SageMaker::Device\": {\n *       \"Properties\": {\n *         \"Device\": {\n *\n * !!!       must have exactly one of 'Type', 'PrimitiveType', found: {\"Type\":\"Device\",\"PrimitiveType\":\"Json\"} !!!\n *\n *           \"Documentation\": \"http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-sagemaker-device.html#cfn-sagemaker-device-device\",\n *           \"UpdateType\": \"Mutable\",\n *           \"Required\": false,\n *           \"PrimitiveType\": \"Json\",\n *           \"Type\": \"Device\"\n *         }\n *       }\n *     }\n *   }\n * }\n * ```\n */\nimport * as fs from 'fs-extra';\n\nexport interface CfnSpec {\n  PropertyTypes: Record<string, any>;\n  ResourceTypes: Record<string, any>;\n  ResourceSpecificationVersion: string;\n}\n\nexport interface ValidationError {\n  readonly value: JsonValue<any>;\n  readonly message: string;\n}\n\nexport class CfnSpecValidator {\n  public static validate(spec: CfnSpec) {\n    const ret = new CfnSpecValidator(spec);\n    ret.validateSpec();\n    return ret.errors;\n  }\n\n  public readonly errors = new Array<ValidationError>();\n  private readonly root: JsonValue<CfnSpec>;\n\n  constructor(spec: CfnSpec) {\n    this.root = JsonValue.of(spec);\n  }\n\n  public validateSpec() {\n    this.assert(this.root.get('PropertyTypes'), isObject, (propTypes) => {\n      this.validateMap(propTypes, (propType) => this.validatePropertyType(propType));\n    });\n\n    this.assert(this.root.get('ResourceTypes'), isObject, (resTypes) => {\n      this.validateMap(resTypes, (propType) => this.validateResourceType(propType));\n    });\n  }\n\n  /**\n   * Property types are extremely weird\n   *\n   * Nominally, they define \"records\" that have a `Properties` field with the defined\n   * properties.\n   *\n   * However, they are also commonly used as aliases for other types, meaning they have\n   * the same type-indicating fields as individual property *fields* would have.\n   *\n   * Also also, it seems to be quite common to have them empty--have no fields at all.\n   * This seems to be taken as an alias for an unstructured `Json` type. It's probably\n   * just a mistake, but unfortunately a mistake that S3 is participating in, so if we\n   * fail on that we won't be able to consume updates to S3's schema. Our codegen is\n   * ready to deal with this and just renders it to an empty struct.\n   */\n  private validatePropertyType(propType: JsonValue<Record<string, any>>) {\n    // If the only set of properties is \"Documentation\", we take this to be an alias\n    // for an empty struct and allow it. I feel icky allowing this, but it seems to\n    // be pragmatic for now.\n    if (Object.keys(propType.value).join(',') === 'Documentation') {\n      return;\n    }\n\n    const properties = propType.get('Properties');\n    if (properties.hasValue) {\n      this.assert(properties, isObject, (props) => {\n        this.validateProperties(props);\n      });\n    } else {\n      this.validateType(propType, 'if a property type doesn\\'t have \"Properties\", it ');\n    }\n  }\n\n  private validateResourceType(resType: JsonValue<any>) {\n    this.assertOptional(resType.get('Properties'), isObject, (props) => {\n      this.validateProperties(props);\n    });\n\n    this.assertOptional(resType.get('Attributes'), isObject, (attrs) => {\n      this.validateMap(attrs, attr => {\n        this.validateType(attr);\n      });\n    });\n  }\n\n  private validateProperties(properties: JsonValue<Record<string, any>>) {\n    this.validateMap(properties, prop => {\n      this.validateType(prop);\n\n      this.assertOptional(prop.get('UpdateType'), (x: any) => {\n        if (!['Mutable', 'Immutable', 'Conditional'].includes(x)) {\n          throw new Error(`invalid value for enum: '${x}'`);\n        }\n      });\n    });\n  }\n\n  /**\n   * Validate the type\n   *\n   * There must be:\n   * - Either Type or PrimitiveType\n   * - Only if Type is List or Map, there will be either an ItemType or a PrimitiveItemType\n   * - Non-primitive Types must correspond to a property type\n   */\n  private validateType(typedObject: JsonValue<Record<string, any>>, errorPrefix = '') {\n    const type = typedObject.get('Type');\n    const primitiveType = typedObject.get('PrimitiveType');\n\n    if (type.hasValue === primitiveType.hasValue) {\n      this.report(typedObject, `${errorPrefix}must have exactly one of 'Type', 'PrimitiveType', found: ${JSON.stringify({\n        Type: type.valueOrUndefined,\n        PrimitiveType: primitiveType.valueOrUndefined,\n      })}`);\n    }\n\n    this.assertOptional(primitiveType, isValidPrimitive);\n\n    let isCollectionType = false;\n    const itemType = typedObject.get('ItemType');\n    const primitiveItemType = typedObject.get('PrimitiveItemType');\n\n    if (type.hasValue) {\n      isCollectionType = COLLECTION_TYPES.includes(type.value);\n      if (isCollectionType) {\n        if (itemType.hasValue === primitiveItemType.hasValue) {\n          this.report(typedObject, `must have exactly one of 'ItemType', 'PrimitiveItemType', found: ${JSON.stringify({\n            ItemType: itemType.valueOrUndefined,\n            PrimitiveItemType: primitiveItemType.valueOrUndefined,\n          })}`);\n        }\n\n        this.assertOptional(primitiveItemType, isValidPrimitive);\n        if (itemType.hasValue) {\n          this.assertValidPropertyTypeReference(itemType);\n        }\n      } else {\n        this.assertValidPropertyTypeReference(type);\n      }\n    }\n\n    if (!isCollectionType) {\n      if (itemType.hasValue || primitiveItemType.hasValue) {\n        this.report(typedObject, 'only \\'List\\' or \\'Map\\' types can have \\'ItemType\\', \\'PrimitiveItemType\\'');\n      }\n    }\n\n    const dupes = typedObject.get('DuplicatesAllowed');\n    if (dupes.hasValue && !isCollectionType) {\n      this.report(dupes, 'occurs on non-collection type');\n    }\n  }\n\n  private assertValidPropertyTypeReference(typeName: JsonValue<string>) {\n    if (BUILTIN_COMPLEX_TYPES.includes(typeName.value)) {\n      return;\n    }\n\n    const cfnName = typeName.path[1]; // AWS::Xyz::Resource[.Property]\n    const namespace = cfnName.split('.')[0];\n\n    const propTypeName = `${namespace}.${typeName.value}`;\n    if (!this.root.get('PropertyTypes').get(propTypeName).hasValue) {\n      this.report(typeName, `unknown property type name '${typeName.value}' (missing definition for '${propTypeName}')`);\n    }\n  }\n\n  private assertOptional<A, B extends A>(x: JsonValue<A>, pred: (x: A) => asserts x is B, block?: (x: JsonValue<B>) => void): boolean {\n    return x.hasValue ? this.assert(x, pred, block) : true;\n  }\n\n  private assert<A, B extends A>(x: JsonValue<A>, pred: (x: A) => asserts x is B, block?: (x: JsonValue<B>) => void): boolean {\n    try {\n      pred(x.value);\n      if (block) {\n        block(new JsonValue(x.value, x.path));\n      }\n      return true;\n    } catch (e) {\n      this.report(x, e.message);\n      return false;\n    }\n  }\n\n  private validateMap<A>(x: JsonValue<Record<string, A>>, block: (x: JsonValue<A>) => void) {\n    for (const key in x.value) {\n      block(x.get(key));\n    }\n  }\n\n  private report(value: JsonValue<any>, message: string) {\n    this.errors.push({ value, message });\n  }\n}\n\nfunction isObject(x: any): asserts x is Record<string, any> {\n  if (x == null || typeof x !== 'object' || Array.isArray(x)) {\n    throw new Error(`expected object, found '${x}'`);\n  }\n}\n\nconst COLLECTION_TYPES = ['List', 'Map'];\nconst BUILTIN_COMPLEX_TYPES = ['Tag'];\n\nfunction isValidPrimitive(x: any): asserts x is string {\n  const primitives = ['String', 'Long', 'Integer', 'Double', 'Boolean', 'Timestamp', 'Json'];\n\n  if (!primitives.includes(x)) {\n    throw new Error(`must be one of ${primitives.join(', ')}, got: ${x}`);\n  }\n}\n\ninterface JsonValue<A> {\n  readonly path: string[];\n  readonly pathValue: any;\n  readonly hasValue: boolean;\n  readonly value: A;\n  readonly valueOrUndefined: A | undefined;\n  get<K extends keyof A>(k: K): JsonValue<A[K]>;\n}\n\nclass JsonValue<A> implements JsonValue<A> {\n  public static of<B>(x: B): JsonValue<B> {\n    return new JsonValue(x, []);\n  }\n\n  public readonly hasValue: boolean = true;\n  public readonly valueOrUndefined: A | undefined = this.value;\n  public readonly pathValue: any = this.value;\n\n  constructor(public readonly value: A, public readonly path: string[]) {\n  }\n\n  public get<K extends keyof A>(k: K): JsonValue<A[K]> {\n    if (!this.value || typeof this.value !== 'object' || Array.isArray(this.value)) {\n      return new ErrorValue(`expected object, found ${this.value}`, this.path, this.value);\n    }\n    const ret = this.value[k];\n    if (ret === undefined) {\n      return new ErrorValue(`missing required key '${k}'`, this.path, this.value);\n    }\n    return new JsonValue(ret, [...this.path, `${k}`]);\n  }\n}\n\nclass ErrorValue<A> implements JsonValue<A> {\n  public readonly hasValue = false;\n  public readonly valueOrUndefined: A | undefined = undefined;\n\n  constructor(private readonly error: string, public readonly path: string[], public readonly pathValue: any) {\n  }\n\n  public get<K extends keyof A>(_k: K): JsonValue<A[K]> {\n    return this as any;\n  }\n\n  public get value(): A {\n    throw new Error(this.error);\n  }\n}\n\nexport function formatErrorInContext(error: ValidationError) {\n  let reportValue = error.value.pathValue;\n  for (let i = error.value.path.length; i > 0; i--) {\n    reportValue = { [error.value.path[i - 1]]: reportValue };\n  }\n\n  const formattedLines = JSON.stringify(reportValue, undefined, 2).split('\\n');\n\n  const indent = 2 * (error.value.path.length + 1);\n\n  // Insert the error message at line N with an appropriate indent\n  formattedLines.splice(error.value.path.length + 1, 0, `\\n!!!${' '.repeat(indent - 3)}${error.message} !!!\\n`);\n\n  return formattedLines.join('\\n');\n}\n\nasync function main(args: string[]) {\n  const spec = await fs.readJson(args[0]);\n  const errors = CfnSpecValidator.validate(spec);\n  if (errors.length !== 0) {\n    for (const error of errors) {\n      console.error(formatErrorInContext(error));\n    }\n    process.exitCode = 1;\n  }\n}\n\nif (require.main === module) {\n  main(process.argv.slice(2)).catch(e => {\n    process.exitCode = 1;\n    // eslint-disable-next-line no-console\n    console.error(e.message);\n  });\n}"]}

package/node_modules/@aws-cdk/cfnspec/coverage/build-tools/index.html

@@ -23,30 +23,30 @@
         <div class='clearfix'>
             
             <div class='fl pad1y space-right2'>
-                <span class="strong">43.01% </span>
+                <span class="strong">62.24% </span>
                 <span class="quiet">Statements</span>
-                <span class='fraction'>40/93</span>
+                <span class='fraction'>183/294</span>
             </div>
         
             
             <div class='fl pad1y space-right2'>
-                <span class="strong">26.66% </span>
+                <span class="strong">45.83% </span>
                 <span class="quiet">Branches</span>
-                <span class='fraction'>12/45</span>
+                <span class='fraction'>55/120</span>
             </div>
         
             
             <div class='fl pad1y space-right2'>
-                <span class="strong">50% </span>
+                <span class="strong">67.16% </span>
                 <span class="quiet">Functions</span>
-                <span class='fraction'>9/18</span>
+                <span class='fraction'>45/67</span>
             </div>
         
             
             <div class='fl pad1y space-right2'>
-                <span class="strong">46.51% </span>
+                <span class="strong">63.53% </span>
                 <span class="quiet">Lines</span>
-                <span class='fraction'>40/86</span>
+                <span class='fraction'>176/277</span>
             </div>
         
             
@@ -61,7 +61,7 @@
             </div>
         </template>
     </div>
-    <div class='status-line low'></div>
+    <div class='status-line medium'></div>
     <div class="pad1">
 <table class="coverage-summary">
 <thead>
@@ -79,18 +79,33 @@
 </tr>
 </thead>
 <tbody><tr>
-	<td class="file low" data-value="massage-spec.ts"><a href="massage-spec.ts.html">massage-spec.ts</a></td>
-	<td data-value="35.59" class="pic low">
-	<div class="chart"><div class="cover-fill" style="width: 35%"></div><div class="cover-empty" style="width: 65%"></div></div>
+	<td class="file medium" data-value="massage-spec.ts"><a href="massage-spec.ts.html">massage-spec.ts</a></td>
+	<td data-value="61.53" class="pic medium">
+	<div class="chart"><div class="cover-fill" style="width: 61%"></div><div class="cover-empty" style="width: 39%"></div></div>
 	</td>
-	<td data-value="35.59" class="pct low">35.59%</td>
-	<td data-value="59" class="abs low">21/59</td>
-	<td data-value="22.72" class="pct low">22.72%</td>
-	<td data-value="22" class="abs low">5/22</td>
+	<td data-value="61.53" class="pct medium">61.53%</td>
+	<td data-value="26" class="abs medium">16/26</td>
 	<td data-value="45.45" class="pct low">45.45%</td>
 	<td data-value="11" class="abs low">5/11</td>
-	<td data-value="37.5" class="pct low">37.5%</td>
-	<td data-value="56" class="abs low">21/56</td>
+	<td data-value="71.42" class="pct medium">71.42%</td>
+	<td data-value="7" class="abs medium">5/7</td>
+	<td data-value="61.53" class="pct medium">61.53%</td>
+	<td data-value="26" class="abs medium">16/26</td>
+	</tr>
+
+<tr>
+	<td class="file medium" data-value="patch-set.ts"><a href="patch-set.ts.html">patch-set.ts</a></td>
+	<td data-value="54.23" class="pic medium">
+	<div class="chart"><div class="cover-fill" style="width: 54%"></div><div class="cover-empty" style="width: 46%"></div></div>
+	</td>
+	<td data-value="54.23" class="pct medium">54.23%</td>
+	<td data-value="118" class="abs medium">64/118</td>
+	<td data-value="37.25" class="pct low">37.25%</td>
+	<td data-value="51" class="abs low">19/51</td>
+	<td data-value="55" class="pct medium">55%</td>
+	<td data-value="20" class="abs medium">11/20</td>
+	<td data-value="55.85" class="pct medium">55.85%</td>
+	<td data-value="111" class="abs medium">62/111</td>
 	</tr>
 
 <tr>
@@ -108,6 +123,21 @@
 	<td data-value="30" class="abs medium">19/30</td>
 	</tr>
 
+<tr>
+	<td class="file high" data-value="validate-cfn.ts"><a href="validate-cfn.ts.html">validate-cfn.ts</a></td>
+	<td data-value="72.41" class="pic high">
+	<div class="chart"><div class="cover-fill" style="width: 72%"></div><div class="cover-empty" style="width: 28%"></div></div>
+	</td>
+	<td data-value="72.41" class="pct high">72.41%</td>
+	<td data-value="116" class="abs high">84/116</td>
+	<td data-value="68.57" class="pct high">68.57%</td>
+	<td data-value="35" class="abs high">24/35</td>
+	<td data-value="75.75" class="pct medium">75.75%</td>
+	<td data-value="33" class="abs medium">25/33</td>
+	<td data-value="71.81" class="pct medium">71.81%</td>
+	<td data-value="110" class="abs medium">79/110</td>
+	</tr>
+
 </tbody>
 </table>
 </div>
@@ -116,9 +146,8 @@
             <div class='footer quiet pad2 space-top1 center small'>
                 Code coverage generated by
                 <a href="https://istanbul.js.org/" target="_blank" rel="noopener">istanbul</a>
-                at Wed Dec 22 2021 09:46:21 GMT+0000 (Coordinated Universal Time)
+                at Sun Jan 09 2022 18:58:21 GMT+0000 (Coordinated Universal Time)
             </div>
-        </div>
         <script src="../prettify.js"></script>
         <script>
             window.onload = function () {