@aws-amplify/graphql-api-construct 1.18.3-ai-next.0 → 1.18.3

package/node_modules/@aws-cdk/cfnspec/build-tools/update-metrics.sh

@@ -0,0 +1,15 @@
+#!/bin/bash
+set -eu
+
+# Run this script on the tarball found in the release artifacts of the CloudWatchConsoleServiceDirectory package.
+
+explorer_tarball="$1"
+
+target_file=lib/canned-metrics/services.json
+
+mkdir -p $(dirname $target_file)
+
+tar xzOf "$explorer_tarball" "package/dist/lib/configuration/generated/services.json" > $target_file.json
+node -p "JSON.stringify(require('./${target_file}.json'), undefined, 2)" > $target_file
+rm $target_file.json
+echo "Wrote $target_file"

package/node_modules/@aws-cdk/cfnspec/build-tools/update.sh

@@ -0,0 +1,113 @@
+#!/bin/bash
+
+###
+# Updates the AWS CloudFormation Resource Specification using the files published on the AWS Documentaiton.
+# See: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cfn-resource-specification.html
+###
+
+set -euo pipefail
+scriptdir=$(cd $(dirname $0) && pwd)
+
+rm -f CHANGELOG.md.new
+
+function update-spec() {
+    local title=$1
+    local url=$2
+    local targetdir=$3
+    local gunzip=$4
+    local split=$5
+    local services=${@:6}
+
+    local tmpdir="$(mktemp -d)"
+    local newspec="${tmpdir}/new_proposed.json"
+    local newcombined="${tmpdir}/new.json"
+    local oldcombined="${tmpdir}/old.json"
+
+    # fail if the spec has changes, otherwise we won't be able to determine the diff
+    if [ -n "$(git status --porcelain ${targetdir})" ]; then
+        echo "The directory ${targetdir} has changes, revert them before cfn-update"
+        exit 1
+    fi
+
+    if [[ "${url}" == "http"* ]]; then
+        echo >&2 "Downloading from ${url}..."
+        if ${gunzip}; then
+            curl -sL "${url}" | gunzip - > ${newspec}
+        else
+            curl -sL "${url}" > ${newspec}
+        fi
+    else
+        echo >&2 "Copying file ${url}..."
+        cp "${url}" "${newspec}"
+    fi
+
+    # Calculate the old and new combined specs, so we can do a diff on the changes
+    echo >&2 "Updating source spec..."
+    mkdir -p ${targetdir}
+
+    node build-tools/patch-set.js --quiet "${targetdir}" "${oldcombined}"
+    if ${split}; then
+        node build-tools/split-spec-by-service.js "${newspec}" "${targetdir}" "${services}"
+    else
+        cp "${newspec}" "${targetdir}/spec.json"
+        sort-json "${targetdir}/spec.json"
+    fi
+    node build-tools/patch-set.js --quiet "${targetdir}" "${newcombined}"
+
+    echo >&2 "Updating CHANGELOG.md..."
+    node build-tools/spec-diff.js "${title}" "${oldcombined}" "${newcombined}" >> CHANGELOG.md.new
+
+    echo "" >> CHANGELOG.md.new
+}
+
+# First run a build to get a complete version of the old spec
+
+update-spec \
+    "CloudFormation Resource Specification" \
+    "${1:-https://d1uauaxba7bl26.cloudfront.net/latest/gzip/CloudFormationResourceSpecification.json}" \
+    spec-source/specification/000_cfn/000_official \
+    true true
+
+update-spec \
+    "CloudFormation Resource Specification (us-west-2)" \
+    "${2:-https://d201a2mn26r7lk.cloudfront.net/latest/gzip/CloudFormationResourceSpecification.json}" \
+    spec-source/specification/001_cfn_us-west-2/000_official \
+    true true AWS_DeviceFarm
+
+old_version=$(cat cfn.version)
+new_version=$(node -p "require('${scriptdir}/../spec-source/specification/000_cfn/000_official/001_Version.json').ResourceSpecificationVersion")
+echo >&2 "Recording new version..."
+rm -f cfn.version
+echo "$new_version" > cfn.version
+
+# Only report outdated specs if we made changes, otherwise we're stuck reporting changes every time.
+if [[ "$new_version" != "$old_version" ]]; then
+    echo >&2 "Reporting outdated specs..."
+    node build-tools/report-issues spec-source/specification/000_cfn/000_official/ outdated >> CHANGELOG.md.new
+    node build-tools/report-issues spec-source/specification/001_cfn_us-west-2/000_official/ outdated >> CHANGELOG.md.new
+fi
+
+update-spec \
+    "Serverless Application Model (SAM) Resource Specification" \
+    "https://raw.githubusercontent.com/awslabs/goformation/master/generate/sam-2016-10-31.json" \
+    spec-source/specification/100_sam/000_official \
+    false false
+
+npm run build
+
+echo >&2 "Creating missing AWS construct libraries for new resource types..."
+node ${scriptdir}/create-missing-libraries.js || {
+    echo "------------------------------------------------------------------------------------"
+    echo "cfn-spec update script failed when trying to create modules for new services"
+    echo "Fix the error (you will likely need to add RefKind patches), and then run 'npm run update' again"
+    exit 1
+}
+
+# append old changelog after new and replace as the last step because otherwise we will not be idempotent
+_changelog_contents=$(cat CHANGELOG.md.new)
+if [ -n "${_changelog_contents}" ]; then
+    cat CHANGELOG.md >> CHANGELOG.md.new
+    cp CHANGELOG.md.new CHANGELOG.md
+fi
+
+exec /bin/bash ${scriptdir}/update-cfnlint.sh

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

@@ -0,0 +1,67 @@
+export interface CfnSpec {
+    PropertyTypes: Record<string, any>;
+    ResourceTypes: Record<string, any>;
+    ResourceSpecificationVersion: string;
+}
+export interface ValidationError {
+    readonly value: JsonValue<any>;
+    readonly message: string;
+}
+export declare class CfnSpecValidator {
+    static validate(spec: CfnSpec): ValidationError[];
+    readonly errors: ValidationError[];
+    private readonly root;
+    constructor(spec: CfnSpec);
+    validateSpec(): void;
+    /**
+     * 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.
+     */
+    private validatePropertyType;
+    private validateResourceType;
+    private validateProperties;
+    /**
+     * 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
+     */
+    private validateType;
+    private assertValidPropertyTypeReference;
+    private assertOptional;
+    private assert;
+    private validateMap;
+    private report;
+}
+interface JsonValue<A> {
+    readonly path: string[];
+    readonly pathValue: any;
+    readonly hasValue: boolean;
+    readonly value: A;
+    readonly valueOrUndefined: A | undefined;
+    get<K extends keyof A>(k: K): JsonValue<A[K]>;
+}
+declare class JsonValue<A> implements JsonValue<A> {
+    readonly value: A;
+    readonly path: string[];
+    static of<B>(x: B): JsonValue<B>;
+    readonly hasValue: boolean;
+    readonly valueOrUndefined: A | undefined;
+    readonly pathValue: any;
+    constructor(value: A, path: string[]);
+}
+export declare function formatErrorInContext(error: ValidationError): string;
+export {};

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/cfn.version

@@ -0,0 +1 @@
+109.0.0

package/node_modules/@aws-cdk/cfnspec/lib/_private_schema/cfn-lint.d.ts

@@ -0,0 +1,24 @@
+/**
+ * All annotations imported from cfn-lint
+ */
+export interface CfnLintFileSchema {
+    /**
+     * Resource types that are in this map are stateful
+     *
+     * There is more information in the structure this maps to.
+     */
+    readonly StatefulResources: {
+        readonly ResourceTypes: Record<string, CfnLintStatefulSchema>;
+    };
+}
+/**
+ * Extra information on stateful resource types
+ */
+export interface CfnLintStatefulSchema {
+    /**
+     * Whether or not a Delete operation requires the resource to be empty
+     *
+     * @default false
+     */
+    readonly DeleteRequiresEmptyResource?: boolean;
+}

package/node_modules/@aws-cdk/cfnspec/lib/_private_schema/cfn-lint.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2ZuLWxpbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJjZm4tbGludC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBBbGwgYW5ub3RhdGlvbnMgaW1wb3J0ZWQgZnJvbSBjZm4tbGludFxuICovXG5leHBvcnQgaW50ZXJmYWNlIENmbkxpbnRGaWxlU2NoZW1hIHtcbiAgLyoqXG4gICAqIFJlc291cmNlIHR5cGVzIHRoYXQgYXJlIGluIHRoaXMgbWFwIGFyZSBzdGF0ZWZ1bFxuICAgKlxuICAgKiBUaGVyZSBpcyBtb3JlIGluZm9ybWF0aW9uIGluIHRoZSBzdHJ1Y3R1cmUgdGhpcyBtYXBzIHRvLlxuICAgKi9cbiAgcmVhZG9ubHkgU3RhdGVmdWxSZXNvdXJjZXM6IHsgcmVhZG9ubHkgUmVzb3VyY2VUeXBlczogUmVjb3JkPHN0cmluZywgQ2ZuTGludFN0YXRlZnVsU2NoZW1hPiB9O1xufVxuXG4vKipcbiAqIEV4dHJhIGluZm9ybWF0aW9uIG9uIHN0YXRlZnVsIHJlc291cmNlIHR5cGVzXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgQ2ZuTGludFN0YXRlZnVsU2NoZW1hIHtcbiAgLyoqXG4gICAqIFdoZXRoZXIgb3Igbm90IGEgRGVsZXRlIG9wZXJhdGlvbiByZXF1aXJlcyB0aGUgcmVzb3VyY2UgdG8gYmUgZW1wdHlcbiAgICpcbiAgICogQGRlZmF1bHQgZmFsc2VcbiAgICovXG4gIHJlYWRvbmx5IERlbGV0ZVJlcXVpcmVzRW1wdHlSZXNvdXJjZT86IGJvb2xlYW47XG59XG4iXX0=

package/node_modules/@aws-cdk/cfnspec/lib/augmentations/AWS_EC2_VPNConnection.json

@@ -0,0 +1,27 @@
+{
+  "options": {
+    "classFile": "vpn",
+    "class": "VpnConnectionBase",
+    "interface": "IVpnConnection"
+  },
+  "metrics": {
+    "namespace": "AWS/VPN",
+    "dimensions": { "VpnId": "this.vpnId" },
+    "metrics": [
+      {
+        "name": "TunnelState",
+        "documentation": "The state of the tunnel. 0 indicates DOWN and 1 indicates UP."
+      },
+      {
+        "name": "TunnelDataIn",
+        "documentation": "The bytes received through the VPN tunnel.",
+        "type": "count"
+      },
+      {
+        "name": "TunnelDataOut",
+        "documentation": "The bytes sent through the VPN tunnel.",
+        "type": "count"
+      }
+    ]
+  }
+}

package/node_modules/@aws-cdk/cfnspec/lib/augmentations/AWS_Lambda_Function.json

@@ -0,0 +1,27 @@
+{
+  "metrics": {
+    "namespace": "AWS/Lambda",
+    "dimensions": { "FunctionName": "this.functionName" },
+    "metrics": [
+      {
+        "name": "Throttles",
+        "documentation": "How often this Lambda is throttled",
+        "type": "count"
+      },
+      {
+        "name": "Invocations",
+        "documentation": "How often this Lambda is invoked",
+        "type": "count"
+      },
+      {
+        "name": "Errors",
+        "documentation": "How many invocations of this Lambda fail",
+        "type": "count"
+      },
+      {
+        "name": "Duration",
+        "documentation": "How long execution of this Lambda takes"
+      }
+    ]
+  }
+}