cdk-common 0.0.67 → 2.0.2

package/node_modules/@aws-cdk/cfnspec/build-tools/create-missing-libraries.js

@@ -0,0 +1,308 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * automatically creates a module for any CloudFormation namespaces that do not
+ * have an AWS construct library.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("path");
+const pkglint = require("@aws-cdk/pkglint");
+const fs = require("fs-extra");
+const cfnspec = require("../lib");
+// don't be a prude:
+/* eslint-disable no-console */
+/* eslint-disable quote-props */
+async function main() {
+    const root = path.join(__dirname, '..', '..');
+    if (path.basename(root) !== '@aws-cdk') {
+        throw new Error(`Something went wrong. We expected ${root} to be the "packages/@aws-cdk" directory. Did you move me?`);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const version = require('../package.json').version;
+    // iterate over all cloudformation namespaces
+    for (const namespace of cfnspec.namespaces()) {
+        const module = pkglint.createModuleDefinitionFromCfnNamespace(namespace);
+        const lowcaseModuleName = module.moduleName.toLocaleLowerCase();
+        const packagePath = path.join(root, module.moduleName);
+        // we already have a module for this namesapce, move on.
+        if (await fs.pathExists(packagePath)) {
+            const packageJsonPath = path.join(packagePath, 'package.json');
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            const packageJson = require(packageJsonPath);
+            let scopes = packageJson['cdk-build'].cloudformation;
+            if (typeof scopes === 'string') {
+                scopes = [scopes];
+            }
+            if (scopes.indexOf(namespace) !== -1) {
+                // V2-style module is already modeled in the root package, nothing to be done!
+                continue;
+            }
+            else if (await fs.pathExists(path.join(root, `${module.moduleFamily}-${module.moduleBaseName}`.toLocaleLowerCase()))) {
+                // V2-style package already has it's own package (legacy behavior), nothing to be done!
+                continue;
+            }
+            else {
+                // V2-style package needs to be added to it's "V1" package... Get down to business!
+                console.error(`Adding ${namespace} to ${module.packageName}`);
+                scopes.push(namespace);
+                packageJson['cdk-build'].cloudformation = scopes;
+                await fs.writeJson(packageJsonPath, packageJson, { encoding: 'utf-8', spaces: 2 });
+                const indexTsPath = path.join(packagePath, 'lib', 'index.ts');
+                const indexTs = [
+                    (await fs.readFile(indexTsPath, { encoding: 'utf8' })).trimRight(),
+                    `// ${namespace} CloudFormation Resources:`,
+                    `export * from './${lowcaseModuleName}.generated';`,
+                ].join('\n');
+                await fs.writeFile(indexTsPath, indexTs, { encoding: 'utf8' });
+                continue;
+            }
+        }
+        async function write(relativePath, contents) {
+            const fullPath = path.join(packagePath, relativePath);
+            const dir = path.dirname(fullPath);
+            await fs.mkdirp(dir);
+            let data;
+            if (typeof contents === 'string') {
+                data = contents.trimLeft(); // trim first newline
+            }
+            else if (Array.isArray(contents)) {
+                data = contents.join('\n');
+            }
+            else if (typeof contents === 'object') {
+                data = JSON.stringify(contents, undefined, 2);
+            }
+            else {
+                throw new Error('Invalid type of contents: ' + contents);
+            }
+            await fs.writeFile(fullPath, data + '\n');
+        }
+        console.log(`generating module for ${module.packageName}...`);
+        const description = `${namespace} Construct Library`;
+        await write('package.json', {
+            name: module.packageName,
+            version,
+            description,
+            main: 'lib/index.js',
+            types: 'lib/index.d.ts',
+            jsii: {
+                outdir: 'dist',
+                projectReferences: true,
+                targets: {
+                    dotnet: {
+                        namespace: module.dotnetPackage,
+                        packageId: module.dotnetPackage,
+                        signAssembly: true,
+                        assemblyOriginatorKeyFile: '../../key.snk',
+                        iconUrl: 'https://raw.githubusercontent.com/aws/aws-cdk/master/logo/default-256-dark.png',
+                    },
+                    java: {
+                        package: `${module.javaGroupId}.${module.javaPackage}`,
+                        maven: {
+                            groupId: module.javaGroupId,
+                            artifactId: module.javaArtifactId,
+                        },
+                    },
+                    python: {
+                        classifiers: [
+                            'Framework :: AWS CDK',
+                            'Framework :: AWS CDK :: 1',
+                        ],
+                        distName: module.pythonDistName,
+                        module: module.pythonModuleName,
+                    },
+                },
+                metadata: {
+                    jsii: {
+                        rosetta: {
+                            strict: true,
+                        },
+                    },
+                },
+            },
+            repository: {
+                type: 'git',
+                url: 'https://github.com/aws/aws-cdk.git',
+                directory: `packages/${module.packageName}`,
+            },
+            homepage: 'https://github.com/aws/aws-cdk',
+            scripts: {
+                build: 'cdk-build',
+                watch: 'cdk-watch',
+                lint: 'cdk-lint',
+                test: 'cdk-test',
+                integ: 'cdk-integ',
+                pkglint: 'pkglint -f',
+                package: 'cdk-package',
+                awslint: 'cdk-awslint',
+                cfn2ts: 'cfn2ts',
+                'build+test': 'yarn build && yarn test',
+                'build+test+package': 'yarn build+test && yarn package',
+                compat: 'cdk-compat',
+                gen: 'cfn2ts',
+                'rosetta:extract': 'yarn --silent jsii-rosetta extract',
+                'build+extract': 'yarn build && yarn rosetta:extract',
+                'build+test+extract': 'yarn build+test && yarn rosetta:extract',
+            },
+            'cdk-build': {
+                cloudformation: namespace,
+                jest: true,
+                env: {
+                    AWSLINT_BASE_CONSTRUCT: 'true',
+                },
+            },
+            keywords: [
+                'aws',
+                'cdk',
+                'constructs',
+                namespace,
+                module.moduleName,
+            ],
+            author: {
+                name: 'Amazon Web Services',
+                url: 'https://aws.amazon.com',
+                organization: true,
+            },
+            license: 'Apache-2.0',
+            devDependencies: {
+                '@aws-cdk/assertions': version,
+                '@aws-cdk/cdk-build-tools': version,
+                '@aws-cdk/cfn2ts': version,
+                '@aws-cdk/pkglint': version,
+                '@types/jest': '^26.0.22',
+            },
+            dependencies: {
+                '@aws-cdk/core': version,
+            },
+            peerDependencies: {
+                '@aws-cdk/core': version,
+            },
+            engines: {
+                node: '>= 10.13.0 <13 || >=13.7.0',
+            },
+            stability: 'experimental',
+            maturity: 'cfn-only',
+            awscdkio: {
+                announce: false,
+            },
+            publishConfig: {
+                tag: 'latest',
+            },
+        });
+        await write('.gitignore', [
+            '*.js',
+            '*.js.map',
+            '*.d.ts',
+            'tsconfig.json',
+            'node_modules',
+            '*.generated.ts',
+            'dist',
+            '.jsii',
+            '',
+            '.LAST_BUILD',
+            '.nyc_output',
+            'coverage',
+            '.nycrc',
+            '.LAST_PACKAGE',
+            '*.snk',
+            'nyc.config.js',
+            '!.eslintrc.js',
+            '!jest.config.js',
+            'junit.xml',
+        ]);
+        await write('.npmignore', [
+            '# Don\'t include original .ts files when doing `npm pack`',
+            '*.ts',
+            '!*.d.ts',
+            'coverage',
+            '.nyc_output',
+            '*.tgz',
+            '',
+            'dist',
+            '.LAST_PACKAGE',
+            '.LAST_BUILD',
+            '!*.js',
+            '',
+            '# Include .jsii',
+            '!.jsii',
+            '',
+            '*.snk',
+            '',
+            '*.tsbuildinfo',
+            '',
+            'tsconfig.json',
+            '',
+            '.eslintrc.js',
+            'jest.config.js',
+            '',
+            '# exclude cdk artifacts',
+            '**/cdk.out',
+            'junit.xml',
+            'test/',
+            '!*.lit.ts',
+        ]);
+        await write('lib/index.ts', [
+            `// ${namespace} CloudFormation Resources:`,
+            `export * from './${lowcaseModuleName}.generated';`,
+        ]);
+        await write(`test/${lowcaseModuleName}.test.ts`, [
+            "import '@aws-cdk/assertions';",
+            "import {} from '../lib';",
+            '',
+            "test('No tests are specified for this package', () => {",
+            '  expect(true).toBe(true);',
+            '});',
+        ]);
+        await pkglint.createLibraryReadme(namespace, path.join(packagePath, 'README.md'));
+        await write('.eslintrc.js', [
+            "const baseConfig = require('@aws-cdk/cdk-build-tools/config/eslintrc');",
+            "baseConfig.parserOptions.project = __dirname + '/tsconfig.json';",
+            'module.exports = baseConfig;',
+        ]);
+        await write('jest.config.js', [
+            "const baseConfig = require('@aws-cdk/cdk-build-tools/config/jest.config');",
+            'module.exports = baseConfig;',
+        ]);
+        await write('rosetta/default.ts-fixture', [
+            "import { Construct } from 'constructs';",
+            "import { Stack } from '@aws-cdk/core';",
+            '',
+            'class MyStack extends Stack {',
+            '  constructor(scope: Construct, id: string) {',
+            '    /// here',
+            '  }',
+            '}',
+        ]);
+        const templateDir = path.join(__dirname, 'template');
+        for (const file of await fs.readdir(templateDir)) {
+            await fs.copy(path.join(templateDir, file), path.join(packagePath, file));
+        }
+        await addDependencyToMegaPackage(path.join('@aws-cdk', 'cloudformation-include'), module.packageName, version, ['dependencies', 'peerDependencies']);
+        await addDependencyToMegaPackage('aws-cdk-lib', module.packageName, version, ['devDependencies']);
+        await addDependencyToMegaPackage('monocdk', module.packageName, version, ['devDependencies']);
+        await addDependencyToMegaPackage('decdk', module.packageName, version, ['dependencies']);
+    }
+}
+/**
+ * A few of our packages (e.g., decdk, aws-cdk-lib) require a dependency on every service package.
+ * This automates adding the dependency (and peer dependency) to the package.json.
+ */
+async function addDependencyToMegaPackage(megaPackageName, packageName, version, dependencyTypes) {
+    const packageJsonPath = path.join(__dirname, '..', '..', '..', megaPackageName, 'package.json');
+    const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf8'));
+    dependencyTypes.forEach(dependencyType => {
+        const unorderedDeps = {
+            ...packageJson[dependencyType],
+            [packageName]: version,
+        };
+        packageJson[dependencyType] = {};
+        Object.keys(unorderedDeps).sort().forEach(k => {
+            packageJson[dependencyType][k] = unorderedDeps[k];
+        });
+    });
+    await fs.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n');
+}
+main().catch(e => {
+    console.error(e);
+    process.exit(1);
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"create-missing-libraries.js","sourceRoot":"","sources":["create-missing-libraries.ts"],"names":[],"mappings":"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","sourcesContent":["#!/usr/bin/env node\n\n/**\n * automatically creates a module for any CloudFormation namespaces that do not\n * have an AWS construct library.\n */\n\nimport * as path from 'path';\nimport * as pkglint from '@aws-cdk/pkglint';\nimport * as fs from 'fs-extra';\nimport * as cfnspec from '../lib';\n\n// don't be a prude:\n/* eslint-disable no-console */\n/* eslint-disable quote-props */\n\nasync function main() {\n  const root = path.join(__dirname, '..', '..');\n  if (path.basename(root) !== '@aws-cdk') {\n    throw new Error(`Something went wrong. We expected ${root} to be the \"packages/@aws-cdk\" directory. Did you move me?`);\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-require-imports\n  const version = require('../package.json').version;\n\n  // iterate over all cloudformation namespaces\n  for (const namespace of cfnspec.namespaces()) {\n    const module = pkglint.createModuleDefinitionFromCfnNamespace(namespace);\n    const lowcaseModuleName = module.moduleName.toLocaleLowerCase();\n    const packagePath = path.join(root, module.moduleName);\n\n    // we already have a module for this namesapce, move on.\n    if (await fs.pathExists(packagePath)) {\n      const packageJsonPath = path.join(packagePath, 'package.json');\n      // eslint-disable-next-line @typescript-eslint/no-require-imports\n      const packageJson = require(packageJsonPath);\n      let scopes: string | string[] = packageJson['cdk-build'].cloudformation;\n      if (typeof scopes === 'string') { scopes = [scopes]; }\n      if (scopes.indexOf(namespace) !== -1) {\n        // V2-style module is already modeled in the root package, nothing to be done!\n        continue;\n      } else if (await fs.pathExists(path.join(root, `${module.moduleFamily}-${module.moduleBaseName}`.toLocaleLowerCase()))) {\n        // V2-style package already has it's own package (legacy behavior), nothing to be done!\n        continue;\n      } else {\n        // V2-style package needs to be added to it's \"V1\" package... Get down to business!\n        console.error(`Adding ${namespace} to ${module.packageName}`);\n        scopes.push(namespace);\n        packageJson['cdk-build'].cloudformation = scopes;\n        await fs.writeJson(packageJsonPath, packageJson, { encoding: 'utf-8', spaces: 2 });\n        const indexTsPath = path.join(packagePath, 'lib', 'index.ts');\n        const indexTs = [\n          (await fs.readFile(indexTsPath, { encoding: 'utf8' })).trimRight(),\n          `// ${namespace} CloudFormation Resources:`,\n          `export * from './${lowcaseModuleName}.generated';`,\n        ].join('\\n');\n        await fs.writeFile(indexTsPath, indexTs, { encoding: 'utf8' });\n        continue;\n      }\n    }\n\n    async function write(relativePath: string, contents: string[] | string | object) {\n      const fullPath = path.join(packagePath, relativePath);\n      const dir = path.dirname(fullPath);\n      await fs.mkdirp(dir);\n\n      let data;\n      if (typeof contents === 'string') {\n        data = contents.trimLeft(); // trim first newline\n      } else if (Array.isArray(contents)) {\n        data = contents.join('\\n');\n      } else if (typeof contents === 'object') {\n        data = JSON.stringify(contents, undefined, 2);\n      } else {\n        throw new Error('Invalid type of contents: ' + contents);\n      }\n\n      await fs.writeFile(fullPath, data + '\\n');\n    }\n\n    console.log(`generating module for ${module.packageName}...`);\n\n    const description = `${namespace} Construct Library`;\n\n    await write('package.json', {\n      name: module.packageName,\n      version,\n      description,\n      main: 'lib/index.js',\n      types: 'lib/index.d.ts',\n      jsii: {\n        outdir: 'dist',\n        projectReferences: true,\n        targets: {\n          dotnet: {\n            namespace: module.dotnetPackage,\n            packageId: module.dotnetPackage,\n            signAssembly: true,\n            assemblyOriginatorKeyFile: '../../key.snk',\n            iconUrl: 'https://raw.githubusercontent.com/aws/aws-cdk/master/logo/default-256-dark.png',\n          },\n          java: {\n            package: `${module.javaGroupId}.${module.javaPackage}`,\n            maven: {\n              groupId: module.javaGroupId,\n              artifactId: module.javaArtifactId,\n            },\n          },\n          python: {\n            classifiers: [\n              'Framework :: AWS CDK',\n              'Framework :: AWS CDK :: 1',\n            ],\n            distName: module.pythonDistName,\n            module: module.pythonModuleName,\n          },\n        },\n        metadata: {\n          jsii: {\n            rosetta: {\n              strict: true,\n            },\n          },\n        },\n      },\n      repository: {\n        type: 'git',\n        url: 'https://github.com/aws/aws-cdk.git',\n        directory: `packages/${module.packageName}`,\n      },\n      homepage: 'https://github.com/aws/aws-cdk',\n      scripts: {\n        build: 'cdk-build',\n        watch: 'cdk-watch',\n        lint: 'cdk-lint',\n        test: 'cdk-test',\n        integ: 'cdk-integ',\n        pkglint: 'pkglint -f',\n        package: 'cdk-package',\n        awslint: 'cdk-awslint',\n        cfn2ts: 'cfn2ts',\n        'build+test': 'yarn build && yarn test',\n        'build+test+package': 'yarn build+test && yarn package',\n        compat: 'cdk-compat',\n        gen: 'cfn2ts',\n        'rosetta:extract': 'yarn --silent jsii-rosetta extract',\n        'build+extract': 'yarn build && yarn rosetta:extract',\n        'build+test+extract': 'yarn build+test && yarn rosetta:extract',\n      },\n      'cdk-build': {\n        cloudformation: namespace,\n        jest: true,\n        env: {\n          AWSLINT_BASE_CONSTRUCT: 'true',\n        },\n      },\n      keywords: [\n        'aws',\n        'cdk',\n        'constructs',\n        namespace,\n        module.moduleName,\n      ],\n      author: {\n        name: 'Amazon Web Services',\n        url: 'https://aws.amazon.com',\n        organization: true,\n      },\n      license: 'Apache-2.0',\n      devDependencies: {\n        '@aws-cdk/assertions': version,\n        '@aws-cdk/cdk-build-tools': version,\n        '@aws-cdk/cfn2ts': version,\n        '@aws-cdk/pkglint': version,\n        '@types/jest': '^26.0.22',\n      },\n      dependencies: {\n        '@aws-cdk/core': version,\n      },\n      peerDependencies: {\n        '@aws-cdk/core': version,\n      },\n      engines: {\n        node: '>= 10.13.0 <13 || >=13.7.0',\n      },\n      stability: 'experimental',\n      maturity: 'cfn-only',\n      awscdkio: {\n        announce: false,\n      },\n      publishConfig: {\n        tag: 'latest',\n      },\n    });\n\n    await write('.gitignore', [\n      '*.js',\n      '*.js.map',\n      '*.d.ts',\n      'tsconfig.json',\n      'node_modules',\n      '*.generated.ts',\n      'dist',\n      '.jsii',\n      '',\n      '.LAST_BUILD',\n      '.nyc_output',\n      'coverage',\n      '.nycrc',\n      '.LAST_PACKAGE',\n      '*.snk',\n      'nyc.config.js',\n      '!.eslintrc.js',\n      '!jest.config.js',\n      'junit.xml',\n    ]);\n\n    await write('.npmignore', [\n      '# Don\\'t include original .ts files when doing `npm pack`',\n      '*.ts',\n      '!*.d.ts',\n      'coverage',\n      '.nyc_output',\n      '*.tgz',\n      '',\n      'dist',\n      '.LAST_PACKAGE',\n      '.LAST_BUILD',\n      '!*.js',\n      '',\n      '# Include .jsii',\n      '!.jsii',\n      '',\n      '*.snk',\n      '',\n      '*.tsbuildinfo',\n      '',\n      'tsconfig.json',\n      '',\n      '.eslintrc.js',\n      'jest.config.js',\n      '',\n      '# exclude cdk artifacts',\n      '**/cdk.out',\n      'junit.xml',\n      'test/',\n      '!*.lit.ts',\n    ]);\n\n    await write('lib/index.ts', [\n      `// ${namespace} CloudFormation Resources:`,\n      `export * from './${lowcaseModuleName}.generated';`,\n    ]);\n\n    await write(`test/${lowcaseModuleName}.test.ts`, [\n      \"import '@aws-cdk/assertions';\",\n      \"import {} from '../lib';\",\n      '',\n      \"test('No tests are specified for this package', () => {\",\n      '  expect(true).toBe(true);',\n      '});',\n    ]);\n\n    await pkglint.createLibraryReadme(namespace, path.join(packagePath, 'README.md'));\n\n    await write('.eslintrc.js', [\n      \"const baseConfig = require('@aws-cdk/cdk-build-tools/config/eslintrc');\",\n      \"baseConfig.parserOptions.project = __dirname + '/tsconfig.json';\",\n      'module.exports = baseConfig;',\n    ]);\n\n    await write('jest.config.js', [\n      \"const baseConfig = require('@aws-cdk/cdk-build-tools/config/jest.config');\",\n      'module.exports = baseConfig;',\n    ]);\n\n    await write('rosetta/default.ts-fixture', [\n      \"import { Construct } from 'constructs';\",\n      \"import { Stack } from '@aws-cdk/core';\",\n      '',\n      'class MyStack extends Stack {',\n      '  constructor(scope: Construct, id: string) {',\n      '    /// here',\n      '  }',\n      '}',\n    ]);\n\n    const templateDir = path.join(__dirname, 'template');\n    for (const file of await fs.readdir(templateDir)) {\n      await fs.copy(path.join(templateDir, file), path.join(packagePath, file));\n    }\n\n    await addDependencyToMegaPackage(path.join('@aws-cdk', 'cloudformation-include'), module.packageName, version, ['dependencies', 'peerDependencies']);\n    await addDependencyToMegaPackage('aws-cdk-lib', module.packageName, version, ['devDependencies']);\n    await addDependencyToMegaPackage('monocdk', module.packageName, version, ['devDependencies']);\n    await addDependencyToMegaPackage('decdk', module.packageName, version, ['dependencies']);\n  }\n}\n\n/**\n * A few of our packages (e.g., decdk, aws-cdk-lib) require a dependency on every service package.\n * This automates adding the dependency (and peer dependency) to the package.json.\n */\nasync function addDependencyToMegaPackage(megaPackageName: string, packageName: string, version: string, dependencyTypes: string[]) {\n  const packageJsonPath = path.join(__dirname, '..', '..', '..', megaPackageName, 'package.json');\n  const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf8'));\n  dependencyTypes.forEach(dependencyType => {\n    const unorderedDeps = {\n      ...packageJson[dependencyType],\n      [packageName]: version,\n    };\n    packageJson[dependencyType] = {};\n    Object.keys(unorderedDeps).sort().forEach(k => {\n      packageJson[dependencyType][k] = unorderedDeps[k];\n    });\n  });\n  await fs.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\\n');\n}\n\nmain().catch(e => {\n  console.error(e);\n  process.exit(1);\n});\n"]}

package/node_modules/@aws-cdk/cfnspec/build-tools/massage-spec.d.ts

@@ -0,0 +1,14 @@
+import { schema } from '../lib';
+export declare function massageSpec(spec: schema.Specification): void;
+export declare function forEachSection(spec: schema.Specification, data: any, cb: (spec: any, fragment: any, path: string[]) => void): void;
+export declare function decorateResourceTypes(data: any): void;
+export declare function merge(spec: any, fragment: any, jsonPath: string[]): void;
+export declare function patch(spec: any, fragment: any): void;
+/**
+ * Modifies the provided specification so that ``ResourceTypes`` and ``PropertyTypes`` are listed in alphabetical order.
+ *
+ * @param spec an AWS CloudFormation Resource Specification document.
+ *
+ * @returns ``spec``, after having sorted the ``ResourceTypes`` and ``PropertyTypes`` sections alphabetically.
+ */
+export declare function normalize(spec: schema.Specification): schema.Specification;

package/node_modules/@aws-cdk/cfnspec/build-tools/massage-spec.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalize = exports.patch = exports.merge = exports.decorateResourceTypes = exports.forEachSection = exports.massageSpec = void 0;
+const fastJsonPatch = require("fast-json-patch");
+const lib_1 = require("../lib");
+const scrutiny_1 = require("./scrutiny");
+function massageSpec(spec) {
+    scrutiny_1.detectScrutinyTypes(spec);
+    replaceIncompleteTypes(spec);
+    dropTypelessAttributes(spec);
+}
+exports.massageSpec = massageSpec;
+function forEachSection(spec, data, cb) {
+    cb(spec.PropertyTypes, data.PropertyTypes, ['PropertyTypes']);
+    cb(spec.ResourceTypes, data.ResourceTypes, ['ResourceTypes']);
+    // Per-resource specs are keyed on ResourceType (singular), but we want it in ResourceTypes (plural)
+    cb(spec.ResourceTypes, data.ResourceType, ['ResourceType']);
+}
+exports.forEachSection = forEachSection;
+function decorateResourceTypes(data) {
+    const requiredTransform = data.ResourceSpecificationTransform;
+    if (!requiredTransform) {
+        return;
+    }
+    const resourceTypes = data.ResourceTypes || data.ResourceType;
+    for (const name of Object.keys(resourceTypes)) {
+        resourceTypes[name].RequiredTransform = requiredTransform;
+    }
+}
+exports.decorateResourceTypes = decorateResourceTypes;
+/**
+ * Fix incomplete type definitions in PropertyTypes
+ *
+ * Some user-defined types are defined to not have any properties, and not
+ * be a collection of other types either. They have no definition at all.
+ *
+ * Add a property object type with empty properties.
+ */
+function replaceIncompleteTypes(spec) {
+    for (const [name, definition] of Object.entries(spec.PropertyTypes)) {
+        if (!lib_1.schema.isRecordType(definition)
+            && !lib_1.schema.isCollectionProperty(definition)
+            && !lib_1.schema.isScalarProperty(definition)
+            && !lib_1.schema.isPrimitiveProperty(definition)) {
+            // eslint-disable-next-line no-console
+            console.log(`[${name}] Incomplete type, adding empty "Properties" field`);
+            definition.Properties = {};
+        }
+    }
+}
+/**
+ * Drop Attributes specified with the different ResourceTypes that have
+ * no type specified.
+ */
+function dropTypelessAttributes(spec) {
+    const resourceTypes = spec.ResourceTypes;
+    Object.values(resourceTypes).forEach((resourceType) => {
+        var _a;
+        const attributes = (_a = resourceType.Attributes) !== null && _a !== void 0 ? _a : {};
+        Object.keys(attributes).forEach((attrKey) => {
+            const attrVal = attributes[attrKey];
+            if (Object.keys(attrVal).length === 0) {
+                delete attributes[attrKey];
+            }
+        });
+    });
+}
+function merge(spec, fragment, jsonPath) {
+    if (!fragment) {
+        return;
+    }
+    for (const key of Object.keys(fragment)) {
+        if (key in spec) {
+            const specVal = spec[key];
+            const fragVal = fragment[key];
+            if (typeof specVal !== typeof fragVal) {
+                // eslint-disable-next-line max-len
+                throw new Error(`Attempted to merge ${JSON.stringify(fragVal)} into incompatible ${JSON.stringify(specVal)} at path ${jsonPath.join('/')}/${key}`);
+            }
+            if (typeof specVal !== 'object') {
+                // eslint-disable-next-line max-len
+                throw new Error(`Conflict when attempting to merge ${JSON.stringify(fragVal)} into ${JSON.stringify(specVal)} at path ${jsonPath.join('/')}/${key}`);
+            }
+            merge(specVal, fragVal, [...jsonPath, key]);
+        }
+        else {
+            spec[key] = fragment[key];
+        }
+    }
+}
+exports.merge = merge;
+function patch(spec, fragment) {
+    if (!fragment) {
+        return;
+    }
+    if ('patch' in fragment) {
+        // eslint-disable-next-line no-console
+        console.log(`Applying patch: ${fragment.patch.description}`);
+        fastJsonPatch.applyPatch(spec, fragment.patch.operations);
+    }
+    else {
+        for (const key of Object.keys(fragment)) {
+            patch(spec[key], fragment[key]);
+        }
+    }
+}
+exports.patch = patch;
+/**
+ * Modifies the provided specification so that ``ResourceTypes`` and ``PropertyTypes`` are listed in alphabetical order.
+ *
+ * @param spec an AWS CloudFormation Resource Specification document.
+ *
+ * @returns ``spec``, after having sorted the ``ResourceTypes`` and ``PropertyTypes`` sections alphabetically.
+ */
+function normalize(spec) {
+    spec.ResourceTypes = normalizeSection(spec.ResourceTypes);
+    if (spec.PropertyTypes) {
+        spec.PropertyTypes = normalizeSection(spec.PropertyTypes);
+    }
+    return spec;
+    function normalizeSection(section) {
+        const result = {};
+        for (const key of Object.keys(section).sort()) {
+            result[key] = section[key];
+        }
+        return result;
+    }
+}
+exports.normalize = normalize;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"massage-spec.js","sourceRoot":"","sources":["massage-spec.ts"],"names":[],"mappings":";;;AAAA,iDAAiD;AACjD,gCAAgC;AAChC,yCAAiD;AAEjD,SAAgB,WAAW,CAAC,IAA0B;IACpD,8BAAmB,CAAC,IAAI,CAAC,CAAC;IAC1B,sBAAsB,CAAC,IAAI,CAAC,CAAC;IAC7B,sBAAsB,CAAC,IAAI,CAAC,CAAC;AAC/B,CAAC;AAJD,kCAIC;AAED,SAAgB,cAAc,CAAC,IAA0B,EAAE,IAAS,EAAE,EAAsD;IAC1H,EAAE,CAAC,IAAI,CAAC,aAAa,EAAE,IAAI,CAAC,aAAa,EAAE,CAAC,eAAe,CAAC,CAAC,CAAC;IAC9D,EAAE,CAAC,IAAI,CAAC,aAAa,EAAE,IAAI,CAAC,aAAa,EAAE,CAAC,eAAe,CAAC,CAAC,CAAC;IAC9D,oGAAoG;IACpG,EAAE,CAAC,IAAI,CAAC,aAAa,EAAE,IAAI,CAAC,YAAY,EAAE,CAAC,cAAc,CAAC,CAAC,CAAC;AAC9D,CAAC;AALD,wCAKC;AAED,SAAgB,qBAAqB,CAAC,IAAS;IAC7C,MAAM,iBAAiB,GAAG,IAAI,CAAC,8BAAoD,CAAC;IACpF,IAAI,CAAC,iBAAiB,EAAE;QAAE,OAAO;KAAE;IACnC,MAAM,aAAa,GAAG,IAAI,CAAC,aAAa,IAAI,IAAI,CAAC,YAAY,CAAC;IAC9D,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,EAAE;QAC7C,aAAa,CAAC,IAAI,CAAC,CAAC,iBAAiB,GAAG,iBAAiB,CAAC;KAC3D;AACH,CAAC;AAPD,sDAOC;AAED;;;;;;;GAOG;AACH,SAAS,sBAAsB,CAAC,IAA0B;IACxD,KAAK,MAAM,CAAC,IAAI,EAAE,UAAU,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,aAAa,CAAC,EAAE;QACnE,IAAI,CAAC,YAAM,CAAC,YAAY,CAAC,UAAU,CAAC;eACjC,CAAC,YAAM,CAAC,oBAAoB,CAAC,UAAU,CAAC;eACxC,CAAC,YAAM,CAAC,gBAAgB,CAAC,UAAU,CAAC;eACpC,CAAC,YAAM,CAAC,mBAAmB,CAAC,UAAU,CAAC,EAAE;YAC1C,sCAAsC;YACtC,OAAO,CAAC,GAAG,CAAC,IAAI,IAAI,oDAAoD,CAAC,CAAC;YAEzE,UAA+C,CAAC,UAAU,GAAG,EAAE,CAAC;SAClE;KACF;AACH,CAAC;AAED;;;GAGG;AACH,SAAS,sBAAsB,CAAC,IAA0B;IACxD,MAAM,aAAa,GAAG,IAAI,CAAC,aAAa,CAAC;IACzC,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,OAAO,CAAC,CAAC,YAAY,EAAE,EAAE;;QACpD,MAAM,UAAU,SAAG,YAAY,CAAC,UAAU,mCAAI,EAAE,CAAC;QACjD,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;YAC1C,MAAM,OAAO,GAAG,UAAU,CAAC,OAAO,CAAC,CAAC;YACpC,IAAI,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,MAAM,KAAK,CAAC,EAAE;gBACrC,OAAO,UAAU,CAAC,OAAO,CAAC,CAAC;aAC5B;QACH,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC;AAED,SAAgB,KAAK,CAAC,IAAS,EAAE,QAAa,EAAE,QAAkB;IAChE,IAAI,CAAC,QAAQ,EAAE;QAAE,OAAO;KAAE;IAC1B,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE;QACvC,IAAI,GAAG,IAAI,IAAI,EAAE;YACf,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC;YAC1B,MAAM,OAAO,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC;YAC9B,IAAI,OAAO,OAAO,KAAK,OAAO,OAAO,EAAE;gBACrC,mCAAmC;gBACnC,MAAM,IAAI,KAAK,CAAC,sBAAsB,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,sBAAsB,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,YAAY,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,GAAG,EAAE,CAAC,CAAC;aACpJ;YACD,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE;gBAC/B,mCAAmC;gBACnC,MAAM,IAAI,KAAK,CAAC,qCAAqC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,SAAS,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,YAAY,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,GAAG,EAAE,CAAC,CAAC;aACtJ;YACD,KAAK,CAAC,OAAO,EAAE,OAAO,EAAE,CAAC,GAAG,QAAQ,EAAE,GAAG,CAAC,CAAC,CAAC;SAC7C;aAAM;YACL,IAAI,CAAC,GAAG,CAAC,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC;SAC3B;KACF;AACH,CAAC;AAnBD,sBAmBC;AAED,SAAgB,KAAK,CAAC,IAAS,EAAE,QAAa;IAC5C,IAAI,CAAC,QAAQ,EAAE;QAAE,OAAO;KAAE;IAC1B,IAAI,OAAO,IAAI,QAAQ,EAAE;QACvB,sCAAsC;QACtC,OAAO,CAAC,GAAG,CAAC,mBAAmB,QAAQ,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC,CAAC;QAC7D,aAAa,CAAC,UAAU,CAAC,IAAI,EAAE,QAAQ,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;KAC3D;SAAM;QACL,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE;YACvC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC;SACjC;KACF;AACH,CAAC;AAXD,sBAWC;AAED;;;;;;GAMG;AACH,SAAgB,SAAS,CAAC,IAA0B;IAClD,IAAI,CAAC,aAAa,GAAG,gBAAgB,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;IAC1D,IAAI,IAAI,CAAC,aAAa,EAAE;QACtB,IAAI,CAAC,aAAa,GAAG,gBAAgB,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;KAC3D;IACD,OAAO,IAAI,CAAC;IAEZ,SAAS,gBAAgB,CAAI,OAA8B;QACzD,MAAM,MAAM,GAA0B,EAAE,CAAC;QACzC,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE;YAC7C,MAAM,CAAC,GAAG,CAAC,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;SAC5B;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;AACH,CAAC;AAdD,8BAcC","sourcesContent":["import * as fastJsonPatch from 'fast-json-patch';\nimport { schema } from '../lib';\nimport { detectScrutinyTypes } from './scrutiny';\n\nexport function massageSpec(spec: schema.Specification) {\n  detectScrutinyTypes(spec);\n  replaceIncompleteTypes(spec);\n  dropTypelessAttributes(spec);\n}\n\nexport function forEachSection(spec: schema.Specification, data: any, cb: (spec: any, fragment: any, path: string[]) => void) {\n  cb(spec.PropertyTypes, data.PropertyTypes, ['PropertyTypes']);\n  cb(spec.ResourceTypes, data.ResourceTypes, ['ResourceTypes']);\n  // Per-resource specs are keyed on ResourceType (singular), but we want it in ResourceTypes (plural)\n  cb(spec.ResourceTypes, data.ResourceType, ['ResourceType']);\n}\n\nexport function decorateResourceTypes(data: any) {\n  const requiredTransform = data.ResourceSpecificationTransform as string | undefined;\n  if (!requiredTransform) { return; }\n  const resourceTypes = data.ResourceTypes || data.ResourceType;\n  for (const name of Object.keys(resourceTypes)) {\n    resourceTypes[name].RequiredTransform = requiredTransform;\n  }\n}\n\n/**\n * Fix incomplete type definitions in PropertyTypes\n *\n * Some user-defined types are defined to not have any properties, and not\n * be a collection of other types either. They have no definition at all.\n *\n * Add a property object type with empty properties.\n */\nfunction replaceIncompleteTypes(spec: schema.Specification) {\n  for (const [name, definition] of Object.entries(spec.PropertyTypes)) {\n    if (!schema.isRecordType(definition)\n    && !schema.isCollectionProperty(definition)\n    && !schema.isScalarProperty(definition)\n    && !schema.isPrimitiveProperty(definition)) {\n      // eslint-disable-next-line no-console\n      console.log(`[${name}] Incomplete type, adding empty \"Properties\" field`);\n\n      (definition as unknown as schema.RecordProperty).Properties = {};\n    }\n  }\n}\n\n/**\n * Drop Attributes specified with the different ResourceTypes that have\n * no type specified.\n */\nfunction dropTypelessAttributes(spec: schema.Specification) {\n  const resourceTypes = spec.ResourceTypes;\n  Object.values(resourceTypes).forEach((resourceType) => {\n    const attributes = resourceType.Attributes ?? {};\n    Object.keys(attributes).forEach((attrKey) => {\n      const attrVal = attributes[attrKey];\n      if (Object.keys(attrVal).length === 0) {\n        delete attributes[attrKey];\n      }\n    });\n  });\n}\n\nexport function merge(spec: any, fragment: any, jsonPath: string[]) {\n  if (!fragment) { return; }\n  for (const key of Object.keys(fragment)) {\n    if (key in spec) {\n      const specVal = spec[key];\n      const fragVal = fragment[key];\n      if (typeof specVal !== typeof fragVal) {\n        // eslint-disable-next-line max-len\n        throw new Error(`Attempted to merge ${JSON.stringify(fragVal)} into incompatible ${JSON.stringify(specVal)} at path ${jsonPath.join('/')}/${key}`);\n      }\n      if (typeof specVal !== 'object') {\n        // eslint-disable-next-line max-len\n        throw new Error(`Conflict when attempting to merge ${JSON.stringify(fragVal)} into ${JSON.stringify(specVal)} at path ${jsonPath.join('/')}/${key}`);\n      }\n      merge(specVal, fragVal, [...jsonPath, key]);\n    } else {\n      spec[key] = fragment[key];\n    }\n  }\n}\n\nexport function patch(spec: any, fragment: any) {\n  if (!fragment) { return; }\n  if ('patch' in fragment) {\n    // eslint-disable-next-line no-console\n    console.log(`Applying patch: ${fragment.patch.description}`);\n    fastJsonPatch.applyPatch(spec, fragment.patch.operations);\n  } else {\n    for (const key of Object.keys(fragment)) {\n      patch(spec[key], fragment[key]);\n    }\n  }\n}\n\n/**\n * Modifies the provided specification so that ``ResourceTypes`` and ``PropertyTypes`` are listed in alphabetical order.\n *\n * @param spec an AWS CloudFormation Resource Specification document.\n *\n * @returns ``spec``, after having sorted the ``ResourceTypes`` and ``PropertyTypes`` sections alphabetically.\n */\nexport function normalize(spec: schema.Specification): schema.Specification {\n  spec.ResourceTypes = normalizeSection(spec.ResourceTypes);\n  if (spec.PropertyTypes) {\n    spec.PropertyTypes = normalizeSection(spec.PropertyTypes);\n  }\n  return spec;\n\n  function normalizeSection<T>(section: { [name: string]: T }): { [name: string]: T } {\n    const result: { [name: string]: T } = {};\n    for (const key of Object.keys(section).sort()) {\n      result[key] = section[key];\n    }\n    return result;\n  }\n}\n"]}

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

@@ -0,0 +1,12 @@
+import { schema } from '../lib';
+/**
+ * Auto-detect common properties to apply scrutiny to by using heuristics
+ *
+ * Manually enhancing scrutiny attributes for each property does not scale
+ * well. Fortunately, the most important ones follow a common naming scheme and
+ * we tag all of them at once in this way.
+ *
+ * If the heuristic scheme gets it wrong in some individual cases, those can be
+ * fixed using schema patches.
+ */
+export declare function detectScrutinyTypes(spec: schema.Specification): void;

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

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectScrutinyTypes = void 0;
+const lib_1 = require("../lib");
+const schema_1 = require("../lib/schema");
+/**
+ * Auto-detect common properties to apply scrutiny to by using heuristics
+ *
+ * Manually enhancing scrutiny attributes for each property does not scale
+ * well. Fortunately, the most important ones follow a common naming scheme and
+ * we tag all of them at once in this way.
+ *
+ * If the heuristic scheme gets it wrong in some individual cases, those can be
+ * fixed using schema patches.
+ */
+function detectScrutinyTypes(spec) {
+    for (const [typeName, typeSpec] of Object.entries(spec.ResourceTypes)) {
+        if (typeSpec.ScrutinyType !== undefined) {
+            continue;
+        } // Already assigned
+        detectResourceScrutiny(typeName, typeSpec);
+        // If a resource scrutiny is set by now, we don't need to look at the properties anymore
+        if (typeSpec.ScrutinyType !== undefined) {
+            continue;
+        }
+        for (const [propertyName, propertySpec] of Object.entries(typeSpec.Properties || {})) {
+            if (propertySpec.ScrutinyType !== undefined) {
+                continue;
+            } // Already assigned
+            detectPropertyScrutiny(typeName, propertyName, propertySpec);
+        }
+    }
+}
+exports.detectScrutinyTypes = detectScrutinyTypes;
+/**
+ * Detect and assign a scrutiny type for the resource
+ */
+function detectResourceScrutiny(typeName, typeSpec) {
+    const properties = Object.entries(typeSpec.Properties || {});
+    // If this resource is named like *Policy and has a PolicyDocument property
+    if (typeName.endsWith('Policy') && properties.some(apply2(isPolicyDocumentProperty))) {
+        typeSpec.ScrutinyType = isIamType(typeName) ? schema_1.ResourceScrutinyType.IdentityPolicyResource : schema_1.ResourceScrutinyType.ResourcePolicyResource;
+        return;
+    }
+}
+/**
+ * Detect and assign a scrutiny type for the property
+ */
+function detectPropertyScrutiny(_typeName, propertyName, propertySpec) {
+    // Detect fields named like ManagedPolicyArns
+    if (propertyName === 'ManagedPolicyArns') {
+        propertySpec.ScrutinyType = schema_1.PropertyScrutinyType.ManagedPolicies;
+        return;
+    }
+    if (propertyName === 'Policies' && lib_1.schema.isComplexListProperty(propertySpec) && propertySpec.ItemType === 'Policy') {
+        propertySpec.ScrutinyType = schema_1.PropertyScrutinyType.InlineIdentityPolicies;
+        return;
+    }
+    if (isPolicyDocumentProperty(propertyName, propertySpec)) {
+        propertySpec.ScrutinyType = schema_1.PropertyScrutinyType.InlineResourcePolicy;
+        return;
+    }
+}
+function isIamType(typeName) {
+    return typeName.indexOf('::IAM::') > 1;
+}
+function isPolicyDocumentProperty(propertyName, propertySpec) {
+    const nameContainsPolicy = propertyName.indexOf('Policy') > -1;
+    const primitiveType = lib_1.schema.isPrimitiveProperty(propertySpec) && propertySpec.PrimitiveType;
+    if (nameContainsPolicy && primitiveType === 'Json') {
+        return true;
+    }
+    return false;
+}
+/**
+ * Make a function that takes 2 arguments take an array of 2 elements instead
+ *
+ * Makes it possible to map it over an array of arrays. TypeScript won't allow
+ * me to overload this type declaration so we need a different function for
+ * every # of arguments.
+ */
+function apply2(fn) {
+    return (as) => fn.apply(fn, as);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/node_modules/@aws-cdk/cfnspec/build-tools/spec-diff.d.ts

@@ -0,0 +1 @@
+export {};