@aws-amplify/graphql-api-construct 1.18.2 → 1.18.3

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

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalize = exports.massageSpec = void 0;
+const scrutiny_1 = require("./scrutiny");
+const lib_1 = require("../lib");
+function massageSpec(spec) {
+    scrutiny_1.detectScrutinyTypes(spec);
+    replaceIncompleteTypes(spec);
+    dropTypelessAttributes(spec);
+}
+exports.massageSpec = massageSpec;
+/**
+ * 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) => {
+        const attributes = resourceType.Attributes ?? {};
+        Object.keys(attributes).forEach((attrKey) => {
+            const attrVal = attributes[attrKey];
+            if (Object.keys(attrVal).length === 0) {
+                delete attributes[attrKey];
+            }
+        });
+    });
+}
+/**
+ * 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,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

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

@@ -0,0 +1,25 @@
+export interface PatchOptions {
+    readonly quiet?: boolean;
+}
+export declare type PatchSet = Record<string, PatchSetElement>;
+export declare type PatchSetElement = {
+    readonly type: 'fragment';
+    readonly data: any;
+} | {
+    readonly type: 'patch';
+    readonly data: any;
+} | {
+    readonly type: 'set';
+    readonly sources: PatchSet;
+};
+export declare function loadPatchSet(sourceDirectory: string, relativeTo?: string): Promise<PatchSet>;
+export declare function evaluatePatchSet(sources: PatchSet, options?: PatchOptions): any;
+/**
+ * Load a patch set from a directory
+ */
+export declare function applyPatchSet(sourceDirectory: string, options?: PatchOptions): Promise<any>;
+/**
+ * Load a patch set and write it out to a file
+ */
+export declare function applyAndWrite(targetFile: string, sourceDirectory: string, options?: PatchOptions): Promise<void>;
+export declare function writeSorted(targetFile: string, data: any): Promise<void>;

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

@@ -0,0 +1,241 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeSorted = exports.applyAndWrite = exports.applyPatchSet = exports.evaluatePatchSet = exports.loadPatchSet = void 0;
+/**
+ * Apply a JSON patch set into the given target file
+ *
+ * The sources can be taken from one or more directories.
+ */
+const path = require("path");
+const fastJsonPatch = require("fast-json-patch");
+const fs = require("fs-extra");
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const sortJson = require('sort-json');
+async function loadPatchSet(sourceDirectory, relativeTo = process.cwd()) {
+    const ret = {};
+    const files = await fs.readdir(sourceDirectory);
+    for (const file of files) {
+        const fullFile = path.join(sourceDirectory, file);
+        const relName = path.relative(relativeTo, fullFile);
+        if (file.startsWith('.')) {
+            // Nothing, ignore
+        }
+        else if ((await fs.stat(fullFile)).isDirectory()) {
+            ret[relName] = {
+                type: 'set',
+                sources: await loadPatchSet(fullFile, sourceDirectory),
+            };
+        }
+        else if (file.endsWith('.json')) {
+            ret[relName] = {
+                type: file.indexOf('patch') === -1 ? 'fragment' : 'patch',
+                data: await fs.readJson(fullFile),
+            };
+        }
+    }
+    return ret;
+}
+exports.loadPatchSet = loadPatchSet;
+function evaluatePatchSet(sources, options = {}) {
+    const targetObject = {};
+    for (const key of Object.keys(sources).sort()) {
+        const value = sources[key];
+        switch (value.type) {
+            case 'fragment':
+                log(key);
+                merge(targetObject, value.data, []);
+                break;
+            case 'patch':
+                patch(targetObject, value.data, (m) => log(`${key}: ${m}`));
+                break;
+            case 'set':
+                const evaluated = evaluatePatchSet(value.sources, options);
+                log(key);
+                merge(targetObject, evaluated, []);
+                break;
+        }
+    }
+    return targetObject;
+    function log(x) {
+        if (!options.quiet) {
+            // eslint-disable-next-line no-console
+            console.log(x);
+        }
+    }
+}
+exports.evaluatePatchSet = evaluatePatchSet;
+/**
+ * Load a patch set from a directory
+ */
+async function applyPatchSet(sourceDirectory, options = {}) {
+    const patches = await loadPatchSet(sourceDirectory);
+    return evaluatePatchSet(patches, options);
+}
+exports.applyPatchSet = applyPatchSet;
+/**
+ * Load a patch set and write it out to a file
+ */
+async function applyAndWrite(targetFile, sourceDirectory, options = {}) {
+    const model = await applyPatchSet(sourceDirectory, options);
+    await writeSorted(targetFile, model);
+}
+exports.applyAndWrite = applyAndWrite;
+async function writeSorted(targetFile, data) {
+    await fs.mkdirp(path.dirname(targetFile));
+    await fs.writeJson(targetFile, sortJson(data), { spaces: 2 });
+}
+exports.writeSorted = writeSorted;
+function printSorted(data) {
+    process.stdout.write(JSON.stringify(sortJson(data), undefined, 2));
+}
+function merge(target, fragment, jsonPath) {
+    if (!fragment) {
+        return;
+    }
+    if (!target || typeof target !== 'object' || Array.isArray(target)) {
+        throw new Error(`Expected object, found: '${target}' at '$.${jsonPath.join('.')}'`);
+    }
+    for (const key of Object.keys(fragment)) {
+        if (key.startsWith('$')) {
+            continue;
+        }
+        if (key in target) {
+            const specVal = target[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 (specVal == fragVal) {
+                continue;
+            }
+            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 {
+            target[key] = fragment[key];
+        }
+    }
+}
+function patch(target, fragment, log) {
+    if (!fragment) {
+        return;
+    }
+    const patches = findPatches(target, fragment);
+    for (const p of patches) {
+        log(p.description ?? '');
+        try {
+            fastJsonPatch.applyPatch(target, p.operations);
+        }
+        catch (e) {
+            throw new Error(`error applying patch: ${JSON.stringify(p, undefined, 2)}: ${e.message}`);
+        }
+    }
+}
+/**
+ * Find the sets of patches to apply in a document
+ *
+ * Adjusts paths to be root-relative, which makes it possible to have paths
+ * point outside the patch scope.
+ */
+function findPatches(data, patchSource) {
+    const ret = [];
+    recurse(data, patchSource, []);
+    return ret;
+    function recurse(actualData, fragment, jsonPath) {
+        if (!fragment) {
+            return;
+        }
+        if ('patch' in fragment) {
+            const p = fragment.patch;
+            if (!p.operations) {
+                throw new Error(`Patch needs 'operations' key, got: ${JSON.stringify(p)}`);
+            }
+            ret.push({
+                description: p.description,
+                operations: p.operations.map((op) => adjustPaths(op, jsonPath)),
+            });
+        }
+        else if ('patch:each' in fragment) {
+            const p = fragment['patch:each'];
+            if (typeof actualData !== 'object') {
+                throw new Error(`Patch ${p.description}: expecting object in data, found '${actualData}'`);
+            }
+            if (!p.operations) {
+                throw new Error(`Patch needs 'operations' key, got: ${JSON.stringify(p)}`);
+            }
+            for (const key in actualData) {
+                ret.push({
+                    description: `${key}: ${p.description}`,
+                    operations: p.operations.map((op) => adjustPaths(op, [...jsonPath, key])),
+                });
+            }
+        }
+        else {
+            for (const key of Object.keys(fragment)) {
+                if (!(key in actualData)) {
+                    actualData[key] = {};
+                }
+                recurse(actualData[key], fragment[key], [...jsonPath, key]);
+            }
+        }
+    }
+    function adjustPaths(op, jsonPath) {
+        return {
+            ...op,
+            ...op.path ? { path: adjustPath(op.path, jsonPath) } : undefined,
+            ...op.from ? { from: adjustPath(op.from, jsonPath) } : undefined,
+        };
+    }
+    /**
+     * Adjust path
+     *
+     * '$/' means from the root, otherwise interpret as relative path.
+     */
+    function adjustPath(originalPath, jsonPath) {
+        if (typeof originalPath !== 'string') {
+            throw new Error(`adjustPath: expected string, got ${JSON.stringify(originalPath)}`);
+        }
+        if (originalPath.startsWith('$/')) {
+            return originalPath.slice(1);
+        }
+        return jsonPath.map(p => `/${p}`).join('') + originalPath;
+    }
+}
+/**
+ * Run this file as a CLI tool, to apply a patch set from the command line
+ */
+async function main(args) {
+    const quiet = eatArg('-q', args) || eatArg('--quiet', args);
+    if (args.length < 1) {
+        throw new Error('Usage: patch-set <DIR> [<FILE>]');
+    }
+    const [dir, targetFile] = args;
+    const model = await applyPatchSet(dir, { quiet });
+    if (targetFile) {
+        await writeSorted(targetFile, model);
+    }
+    else {
+        printSorted(model);
+    }
+}
+function eatArg(arg, args) {
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === arg) {
+            args.splice(i, 1);
+            return true;
+        }
+    }
+    return false;
+}
+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":"patch-set.js","sourceRoot":"","sources":["patch-set.ts"],"names":[],"mappings":"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","sourcesContent":["\n/**\n * Apply a JSON patch set into the given target file\n *\n * The sources can be taken from one or more directories.\n */\nimport * as path from 'path';\nimport * as fastJsonPatch from 'fast-json-patch';\nimport * as fs from 'fs-extra';\n\n// eslint-disable-next-line @typescript-eslint/no-require-imports\nconst sortJson = require('sort-json');\n\nexport interface PatchOptions {\n  readonly quiet?: boolean;\n}\n\nexport type PatchSet = Record<string, PatchSetElement>;\n\nexport type PatchSetElement =\n  | { readonly type: 'fragment'; readonly data: any }\n  | { readonly type: 'patch'; readonly data: any }\n  | { readonly type: 'set'; readonly sources: PatchSet }\n  ;\n\nexport async function loadPatchSet(sourceDirectory: string, relativeTo = process.cwd()): Promise<PatchSet> {\n  const ret: PatchSet = {};\n\n  const files = await fs.readdir(sourceDirectory);\n  for (const file of files) {\n    const fullFile = path.join(sourceDirectory, file);\n    const relName = path.relative(relativeTo, fullFile);\n\n    if (file.startsWith('.')) {\n      // Nothing, ignore\n    } else if ((await fs.stat(fullFile)).isDirectory()) {\n      ret[relName] = {\n        type: 'set',\n        sources: await loadPatchSet(fullFile, sourceDirectory),\n      };\n    } else if (file.endsWith('.json')) {\n      ret[relName] = {\n        type: file.indexOf('patch') === -1 ? 'fragment' : 'patch',\n        data: await fs.readJson(fullFile),\n      };\n    }\n  }\n\n  return ret;\n}\n\nexport function evaluatePatchSet(sources: PatchSet, options: PatchOptions = {}) {\n  const targetObject: any = {};\n\n  for (const key of Object.keys(sources).sort()) {\n    const value = sources[key];\n\n    switch (value.type) {\n      case 'fragment':\n        log(key);\n        merge(targetObject, value.data, []);\n        break;\n      case 'patch':\n        patch(targetObject, value.data, (m) => log(`${key}: ${m}`));\n        break;\n      case 'set':\n        const evaluated = evaluatePatchSet(value.sources, options);\n        log(key);\n        merge(targetObject, evaluated, []);\n        break;\n    }\n  }\n\n  return targetObject;\n\n  function log(x: string) {\n    if (!options.quiet) {\n      // eslint-disable-next-line no-console\n      console.log(x);\n    }\n  }\n}\n\n/**\n * Load a patch set from a directory\n */\nexport async function applyPatchSet(sourceDirectory: string, options: PatchOptions = {}) {\n  const patches = await loadPatchSet(sourceDirectory);\n  return evaluatePatchSet(patches, options);\n}\n\n/**\n * Load a patch set and write it out to a file\n */\nexport async function applyAndWrite(targetFile: string, sourceDirectory: string, options: PatchOptions = {}) {\n  const model = await applyPatchSet(sourceDirectory, options);\n  await writeSorted(targetFile, model);\n}\n\nexport async function writeSorted(targetFile: string, data: any) {\n  await fs.mkdirp(path.dirname(targetFile));\n  await fs.writeJson(targetFile, sortJson(data), { spaces: 2 });\n}\n\nfunction printSorted(data: any) {\n  process.stdout.write(JSON.stringify(sortJson(data), undefined, 2));\n}\n\nfunction merge(target: any, fragment: any, jsonPath: string[]) {\n  if (!fragment) { return; }\n  if (!target || typeof target !== 'object' || Array.isArray(target)) {\n    throw new Error(`Expected object, found: '${target}' at '$.${jsonPath.join('.')}'`);\n  }\n\n  for (const key of Object.keys(fragment)) {\n    if (key.startsWith('$')) { continue; }\n\n    if (key in target) {\n      const specVal = target[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 (specVal == fragVal) {\n        continue;\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      target[key] = fragment[key];\n    }\n  }\n}\n\nfunction patch(target: any, fragment: any, log: (x: string) => void) {\n  if (!fragment) { return; }\n\n  const patches = findPatches(target, fragment);\n  for (const p of patches) {\n    log(p.description ?? '');\n\n    try {\n      fastJsonPatch.applyPatch(target, p.operations);\n    } catch (e) {\n      throw new Error(`error applying patch: ${JSON.stringify(p, undefined, 2)}: ${e.message}`);\n    }\n  }\n}\n\ninterface Patch {\n  readonly description?: string;\n  readonly operations: Operation[];\n}\n\ntype Operation =\n  | { readonly op: 'add'; readonly path: string; readonly value: any }\n  | { readonly op: 'remove'; readonly path: string }\n  | { readonly op: 'replace'; readonly path: string; readonly value: any }\n  | { readonly op: 'copy'; readonly path: string; readonly from: string }\n  | { readonly op: 'move'; readonly path: string; readonly from: string }\n  | { readonly op: 'test'; readonly path: string; readonly value: any }\n  ;\n\n/**\n * Find the sets of patches to apply in a document\n *\n * Adjusts paths to be root-relative, which makes it possible to have paths\n * point outside the patch scope.\n */\nfunction findPatches(data: any, patchSource: any): Patch[] {\n  const ret: Patch[] = [];\n  recurse(data, patchSource, []);\n  return ret;\n\n  function recurse(actualData: any, fragment: any, jsonPath: string[]) {\n    if (!fragment) { return; }\n\n    if ('patch' in fragment) {\n      const p = fragment.patch;\n      if (!p.operations) {\n        throw new Error(`Patch needs 'operations' key, got: ${JSON.stringify(p)}`);\n      }\n      ret.push({\n        description: p.description,\n        operations: p.operations.map((op: any) => adjustPaths(op, jsonPath)),\n      });\n    } else if ('patch:each' in fragment) {\n      const p = fragment['patch:each'];\n      if (typeof actualData !== 'object') {\n        throw new Error(`Patch ${p.description}: expecting object in data, found '${actualData}'`);\n      }\n      if (!p.operations) {\n        throw new Error(`Patch needs 'operations' key, got: ${JSON.stringify(p)}`);\n      }\n      for (const key in actualData) {\n        ret.push({\n          description: `${key}: ${p.description}`,\n          operations: p.operations.map((op: any) => adjustPaths(op, [...jsonPath, key])),\n        });\n      }\n    } else {\n      for (const key of Object.keys(fragment)) {\n        if (!(key in actualData)) {\n          actualData[key] = {};\n        }\n        recurse(actualData[key], fragment[key], [...jsonPath, key]);\n      }\n    }\n  }\n\n  function adjustPaths(op: any, jsonPath: string[]): Operation {\n    return {\n      ...op,\n      ...op.path ? { path: adjustPath(op.path, jsonPath) } : undefined,\n      ...op.from ? { from: adjustPath(op.from, jsonPath) } : undefined,\n    };\n  }\n\n  /**\n   * Adjust path\n   *\n   * '$/' means from the root, otherwise interpret as relative path.\n   */\n  function adjustPath(originalPath: string, jsonPath: string[]): string {\n    if (typeof originalPath !== 'string') {\n      throw new Error(`adjustPath: expected string, got ${JSON.stringify(originalPath)}`);\n    }\n    if (originalPath.startsWith('$/')) {\n      return originalPath.slice(1);\n    }\n    return jsonPath.map(p => `/${p}`).join('') + originalPath;\n  }\n}\n\n\n/**\n * Run this file as a CLI tool, to apply a patch set from the command line\n */\nasync function main(args: string[]) {\n  const quiet = eatArg('-q', args) || eatArg('--quiet', args);\n\n  if (args.length < 1) {\n    throw new Error('Usage: patch-set <DIR> [<FILE>]');\n  }\n\n  const [dir, targetFile] = args;\n\n  const model = await applyPatchSet(dir, { quiet });\n  if (targetFile) {\n    await writeSorted(targetFile, model);\n  } else {\n    printSorted(model);\n  }\n}\n\nfunction eatArg(arg: string, args: string[]) {\n  for (let i = 0; i < args.length; i++) {\n    if (args[i] === arg) {\n      args.splice(i, 1);\n      return true;\n    }\n  }\n  return false;\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}\n"]}

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

@@ -0,0 +1,9 @@
+/**
+ * Report on spec fragment files that are being held back.
+ *
+ * Report formats:
+ *
+ * - 'outdated'/'changelog': print for changelog format
+ * - 'rejected': print validation errors, exit with error code 1 if there are any
+ */
+export {};

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

@@ -0,0 +1,72 @@
+"use strict";
+/* eslint-disable no-console */
+/**
+ * Report on spec fragment files that are being held back.
+ *
+ * Report formats:
+ *
+ * - 'outdated'/'changelog': print for changelog format
+ * - 'rejected': print validation errors, exit with error code 1 if there are any
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("path");
+const fs = require("fs-extra");
+const validate_cfn_1 = require("./validate-cfn");
+async function main(args) {
+    if (args.length < 2) {
+        throw new Error('Usage: report-issues <DIR> <FORMAT>');
+    }
+    const [dir, format] = args;
+    const officialVersion = (await fs.readJson(path.join(dir, '001_Version.json'))).ResourceSpecificationVersion;
+    let headerPrinted = false;
+    for (const file of await fs.readdir(dir)) {
+        if (!file.startsWith('000_')) {
+            continue;
+        }
+        const json = await fs.readJson(path.join(dir, file));
+        const fragmentVersion = json.$version;
+        const serviceName = file.replace(/^000_/, '').replace(/\.json$/, '').replace('_', '::');
+        switch (format) {
+            case 'outdated':
+            case 'changelog':
+                if (fragmentVersion !== officialVersion) {
+                    if (!headerPrinted) {
+                        console.log('## Unapplied changes');
+                        console.log('');
+                        headerPrinted = true;
+                    }
+                    console.log(`* ${serviceName} is at ${fragmentVersion}`);
+                }
+                break;
+            case 'rejected':
+                if (fragmentVersion !== officialVersion) {
+                    // Read the 'rejected' file, parse it (which we expect to fail)
+                    // and print the failures.
+                    const rejectedFileName = `.${file.replace(/.json$/, '.rejected.json')}`;
+                    const rejectedPath = path.join(dir, rejectedFileName);
+                    if (!await fs.pathExists(rejectedPath)) {
+                        // If for whatever reason the file doesn't exist, ignore
+                        continue;
+                    }
+                    const rejectedSpec = await fs.readJson(rejectedPath);
+                    const errors = validate_cfn_1.CfnSpecValidator.validate(rejectedSpec);
+                    console.warn('='.repeat(70));
+                    console.warn(' '.repeat(Math.floor(35 - serviceName.length / 2)) + serviceName);
+                    console.warn('='.repeat(70));
+                    for (const error of errors) {
+                        console.warn(validate_cfn_1.formatErrorInContext(error));
+                        process.exitCode = 1;
+                    }
+                }
+                break;
+            default:
+                throw new Error(`Unknown format type requested: ${format}`);
+        }
+    }
+}
+main(process.argv.slice(2)).catch(e => {
+    // eslint-disable-next-line no-console
+    console.error(e);
+    process.exitCode = 1;
+});
+//# sourceMappingURL=data:application/json;base64,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

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 {};