cdk-common 2.0.28 → 2.0.32

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

@@ -0,0 +1,239 @@
+"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 ((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) {
+    var _a;
+    if (!fragment) {
+        return;
+    }
+    const patches = findPatches(target, fragment);
+    for (const p of patches) {
+        log((_a = p.description) !== null && _a !== void 0 ? _a : '');
+        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.substr(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":";;;AACA;;;;GAIG;AACH,6BAA6B;AAC7B,iDAAiD;AACjD,+BAA+B;AAE/B,iEAAiE;AACjE,MAAM,QAAQ,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;AAc/B,KAAK,UAAU,YAAY,CAAC,eAAuB,EAAE,UAAU,GAAG,OAAO,CAAC,GAAG,EAAE;IACpF,MAAM,GAAG,GAAa,EAAE,CAAC;IAEzB,MAAM,KAAK,GAAG,MAAM,EAAE,CAAC,OAAO,CAAC,eAAe,CAAC,CAAC;IAChD,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE;QACxB,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE,IAAI,CAAC,CAAC;QAClD,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;QAEpD,IAAI,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,WAAW,EAAE,EAAE;YAC3C,GAAG,CAAC,OAAO,CAAC,GAAG;gBACb,IAAI,EAAE,KAAK;gBACX,OAAO,EAAE,MAAM,YAAY,CAAC,QAAQ,EAAE,eAAe,CAAC;aACvD,CAAC;SACH;aAAM,IAAI,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE;YACjC,GAAG,CAAC,OAAO,CAAC,GAAG;gBACb,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,OAAO;gBACzD,IAAI,EAAE,MAAM,EAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC;aAClC,CAAC;SACH;KACF;IAED,OAAO,GAAG,CAAC;AACb,CAAC;AAtBD,oCAsBC;AAED,SAAgB,gBAAgB,CAAC,OAAiB,EAAE,UAAwB,EAAE;IAC5E,MAAM,YAAY,GAAQ,EAAE,CAAC;IAE7B,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE;QAC7C,MAAM,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;QAE3B,QAAQ,KAAK,CAAC,IAAI,EAAE;YAClB,KAAK,UAAU;gBACb,GAAG,CAAC,GAAG,CAAC,CAAC;gBACT,KAAK,CAAC,YAAY,EAAE,KAAK,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;gBACpC,MAAM;YACR,KAAK,OAAO;gBACV,KAAK,CAAC,YAAY,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,GAAG,GAAG,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC;gBAC5D,MAAM;YACR,KAAK,KAAK;gBACR,MAAM,SAAS,GAAG,gBAAgB,CAAC,KAAK,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;gBAC3D,GAAG,CAAC,GAAG,CAAC,CAAC;gBACT,KAAK,CAAC,YAAY,EAAE,SAAS,EAAE,EAAE,CAAC,CAAC;gBACnC,MAAM;SACT;KACF;IAED,OAAO,YAAY,CAAC;IAEpB,SAAS,GAAG,CAAC,CAAS;QACpB,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE;YAClB,sCAAsC;YACtC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;SAChB;IACH,CAAC;AACH,CAAC;AA9BD,4CA8BC;AAED;;GAEG;AACI,KAAK,UAAU,aAAa,CAAC,eAAuB,EAAE,UAAwB,EAAE;IACrF,MAAM,OAAO,GAAG,MAAM,YAAY,CAAC,eAAe,CAAC,CAAC;IACpD,OAAO,gBAAgB,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;AAC5C,CAAC;AAHD,sCAGC;AAED;;GAEG;AACI,KAAK,UAAU,aAAa,CAAC,UAAkB,EAAE,eAAuB,EAAE,UAAwB,EAAE;IACzG,MAAM,KAAK,GAAG,MAAM,aAAa,CAAC,eAAe,EAAE,OAAO,CAAC,CAAC;IAC5D,MAAM,WAAW,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;AACvC,CAAC;AAHD,sCAGC;AAEM,KAAK,UAAU,WAAW,CAAC,UAAkB,EAAE,IAAS;IAC7D,MAAM,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC;IAC1C,MAAM,EAAE,CAAC,SAAS,CAAC,UAAU,EAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC,CAAC;AAChE,CAAC;AAHD,kCAGC;AAED,SAAS,WAAW,CAAC,IAAS;IAC5B,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC,CAAC;AACrE,CAAC;AAED,SAAS,KAAK,CAAC,MAAW,EAAE,QAAa,EAAE,QAAkB;IAC3D,IAAI,CAAC,QAAQ,EAAE;QAAE,OAAO;KAAE;IAC1B,IAAI,CAAC,MAAM,IAAI,OAAO,MAAM,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;QAClE,MAAM,IAAI,KAAK,CAAC,4BAA4B,MAAM,WAAW,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;KACrF;IAED,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE;QACvC,IAAI,GAAG,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE;YAAE,SAAS;SAAE;QAEtC,IAAI,GAAG,IAAI,MAAM,EAAE;YACjB,MAAM,OAAO,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;YAC5B,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,IAAI,OAAO,EAAE;gBACtB,SAAS;aACV;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,MAAM,CAAC,GAAG,CAAC,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC;SAC7B;KACF;AACH,CAAC;AAED,SAAS,KAAK,CAAC,MAAW,EAAE,QAAa,EAAE,GAAwB;;IACjE,IAAI,CAAC,QAAQ,EAAE;QAAE,OAAO;KAAE;IAE1B,MAAM,OAAO,GAAG,WAAW,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IAC9C,KAAK,MAAM,CAAC,IAAI,OAAO,EAAE;QACvB,GAAG,OAAC,CAAC,CAAC,WAAW,mCAAI,EAAE,CAAC,CAAC;QAEzB,IAAI;YACF,aAAa,CAAC,UAAU,CAAC,MAAM,EAAE,CAAC,CAAC,UAAU,CAAC,CAAC;SAChD;QAAC,OAAO,CAAC,EAAE;YACV,MAAM,IAAI,KAAK,CAAC,yBAAyB,IAAI,CAAC,SAAS,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC;SAC3F;KACF;AACH,CAAC;AAgBD;;;;;GAKG;AACH,SAAS,WAAW,CAAC,IAAS,EAAE,WAAgB;IAC9C,MAAM,GAAG,GAAY,EAAE,CAAC;IACxB,OAAO,CAAC,IAAI,EAAE,WAAW,EAAE,EAAE,CAAC,CAAC;IAC/B,OAAO,GAAG,CAAC;IAEX,SAAS,OAAO,CAAC,UAAe,EAAE,QAAa,EAAE,QAAkB;QACjE,IAAI,CAAC,QAAQ,EAAE;YAAE,OAAO;SAAE;QAE1B,IAAI,OAAO,IAAI,QAAQ,EAAE;YACvB,MAAM,CAAC,GAAG,QAAQ,CAAC,KAAK,CAAC;YACzB,IAAI,CAAC,CAAC,CAAC,UAAU,EAAE;gBACjB,MAAM,IAAI,KAAK,CAAC,sCAAsC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;aAC5E;YACD,GAAG,CAAC,IAAI,CAAC;gBACP,WAAW,EAAE,CAAC,CAAC,WAAW;gBAC1B,UAAU,EAAE,CAAC,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,EAAO,EAAE,EAAE,CAAC,WAAW,CAAC,EAAE,EAAE,QAAQ,CAAC,CAAC;aACrE,CAAC,CAAC;SACJ;aAAM,IAAI,YAAY,IAAI,QAAQ,EAAE;YACnC,MAAM,CAAC,GAAG,QAAQ,CAAC,YAAY,CAAC,CAAC;YACjC,IAAI,OAAO,UAAU,KAAK,QAAQ,EAAE;gBAClC,MAAM,IAAI,KAAK,CAAC,SAAS,CAAC,CAAC,WAAW,sCAAsC,UAAU,GAAG,CAAC,CAAC;aAC5F;YACD,IAAI,CAAC,CAAC,CAAC,UAAU,EAAE;gBACjB,MAAM,IAAI,KAAK,CAAC,sCAAsC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;aAC5E;YACD,KAAK,MAAM,GAAG,IAAI,UAAU,EAAE;gBAC5B,GAAG,CAAC,IAAI,CAAC;oBACP,WAAW,EAAE,GAAG,GAAG,KAAK,CAAC,CAAC,WAAW,EAAE;oBACvC,UAAU,EAAE,CAAC,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,EAAO,EAAE,EAAE,CAAC,WAAW,CAAC,EAAE,EAAE,CAAC,GAAG,QAAQ,EAAE,GAAG,CAAC,CAAC,CAAC;iBAC/E,CAAC,CAAC;aACJ;SACF;aAAM;YACL,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE;gBACvC,IAAI,CAAC,CAAC,GAAG,IAAI,UAAU,CAAC,EAAE;oBACxB,UAAU,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC;iBACtB;gBACD,OAAO,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,QAAQ,EAAE,GAAG,CAAC,CAAC,CAAC;aAC7D;SACF;IACH,CAAC;IAED,SAAS,WAAW,CAAC,EAAO,EAAE,QAAkB;QAC9C,OAAO;YACL,GAAG,EAAE;YACL,GAAG,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC,SAAS;YAChE,GAAG,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC,SAAS;SACjE,CAAC;IACJ,CAAC;IAED;;;;OAIG;IACH,SAAS,UAAU,CAAC,YAAoB,EAAE,QAAkB;QAC1D,IAAI,OAAO,YAAY,KAAK,QAAQ,EAAE;YACpC,MAAM,IAAI,KAAK,CAAC,oCAAoC,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,EAAE,CAAC,CAAC;SACrF;QACD,IAAI,YAAY,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE;YACjC,OAAO,YAAY,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;SAC/B;QACD,OAAO,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,GAAG,YAAY,CAAC;IAC5D,CAAC;AACH,CAAC;AAGD;;GAEG;AACH,KAAK,UAAU,IAAI,CAAC,IAAc;IAChC,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,MAAM,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;IAE5D,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE;QACnB,MAAM,IAAI,KAAK,CAAC,iCAAiC,CAAC,CAAC;KACpD;IAED,MAAM,CAAC,GAAG,EAAE,UAAU,CAAC,GAAG,IAAI,CAAC;IAE/B,MAAM,KAAK,GAAG,MAAM,aAAa,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;IAClD,IAAI,UAAU,EAAE;QACd,MAAM,WAAW,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;KACtC;SAAM;QACL,WAAW,CAAC,KAAK,CAAC,CAAC;KACpB;AACH,CAAC;AAED,SAAS,MAAM,CAAC,GAAW,EAAE,IAAc;IACzC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;QACpC,IAAI,IAAI,CAAC,CAAC,CAAC,KAAK,GAAG,EAAE;YACnB,IAAI,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;YAClB,OAAO,IAAI,CAAC;SACb;KACF;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED,IAAI,OAAO,CAAC,IAAI,KAAK,MAAM,EAAE;IAC3B,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE;QACpC,OAAO,CAAC,QAAQ,GAAG,CAAC,CAAC;QACrB,sCAAsC;QACtC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;IAC3B,CAAC,CAAC,CAAC;CACJ","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 ((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.substr(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,4 @@
+/**
+ * Report on spec fragment files that are being held back.
+ */
+export {};

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

@@ -0,0 +1,44 @@
+"use strict";
+/* eslint-disable no-console */
+/**
+ * Report on spec fragment files that are being held back.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("path");
+const fs = require("fs-extra");
+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;
+        switch (format) {
+            case 'outdated':
+                if (fragmentVersion !== officialVersion) {
+                    if (!headerPrinted) {
+                        console.log('## Unapplied changes');
+                        console.log('');
+                        headerPrinted = true;
+                    }
+                    const serviceName = file.replace(/^000_/, '').replace(/\.json$/, '').replace('_', '::');
+                    console.log(`* ${serviceName} is at ${fragmentVersion}`);
+                }
+                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/split-spec-by-service.d.ts

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

package/node_modules/@aws-cdk/cfnspec/build-tools/split-spec-by-service.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable no-console */
+/**
+ * Split the given CloudFormation resource specification up into a patch set, by service
+ *
+ * After splitting, only write out those fragments that are valid.(*)
+ *
+ * The reason for this is that some service updates sometimes contain mistakes,
+ * and we want to be able to take partial upgrades. By splitting the spec, we can
+ * take updates to some services while leaving updates to other services behind.
+ *
+ * (*) If `NO_VALIDATE` is set, all pieces are written out. In normal operation this
+ *     should not be used.
+ */
+const path = require("path");
+const fs = require("fs-extra");
+const patch_set_1 = require("./patch-set");
+const validate_cfn_1 = require("./validate-cfn");
+async function main(args) {
+    if (args.length < 2) {
+        throw new Error('Usage: split-spec-by-service <SPECFILE> <DIRECTORY>');
+    }
+    const [specFile, outDir] = args;
+    log(`Loading specification: ${specFile}`);
+    const spec = await fs.readJson(specFile);
+    // Split
+    log('Splitting');
+    const byService = {};
+    for (const [propTypeName, propType] of Object.entries(spec.PropertyTypes)) {
+        const svcName = serviceName(propTypeName);
+        serviceSpec(svcName).PropertyTypes[propTypeName] = propType;
+    }
+    for (const [resTypeName, resType] of Object.entries(spec.ResourceTypes)) {
+        const svcName = serviceName(resTypeName);
+        serviceSpec(svcName).ResourceTypes[resTypeName] = resType;
+    }
+    // Write out
+    log('Writing');
+    for (const [svcName, svcSpec] of Object.entries(byService)) {
+        const errors = !process.env.NO_VALIDATE ? validate_cfn_1.CfnSpecValidator.validate(svcSpec) : [];
+        if (errors.length === 0) {
+            // Change 'ResourceSpecificationVersion' to '$version', otherwise they will all conflict
+            const toWrite = {
+                PropertyTypes: svcSpec.PropertyTypes,
+                ResourceTypes: svcSpec.ResourceTypes,
+                $version: svcSpec.ResourceSpecificationVersion,
+            };
+            await patch_set_1.writeSorted(path.join(outDir, `000_${svcName}.json`), toWrite);
+        }
+        else {
+            console.warn('='.repeat(70));
+            console.warn(' '.repeat(Math.floor(35 - svcName.length / 2)) + svcName);
+            console.warn('='.repeat(70));
+            for (const error of errors) {
+                console.warn(validate_cfn_1.formatErrorInContext(error));
+            }
+        }
+    }
+    await fs.writeJson(path.join(outDir, '001_Version.json'), {
+        ResourceSpecificationVersion: spec.ResourceSpecificationVersion,
+    }, { spaces: 2 });
+    function serviceSpec(svcName) {
+        if (!(svcName in byService)) {
+            byService[svcName] = {
+                PropertyTypes: {},
+                ResourceTypes: {},
+                ResourceSpecificationVersion: spec.ResourceSpecificationVersion,
+            };
+        }
+        return byService[svcName];
+    }
+}
+function serviceName(x) {
+    return x.split('::').slice(0, 2).join('_');
+}
+function log(x) {
+    // eslint-disable-next-line no-console
+    console.log(x);
+}
+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/template/LICENSE

@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright 2018-2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+   Copyright 2018-2022 Amazon.com, Inc. or its affiliates. All Rights Reserved.
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

package/node_modules/@aws-cdk/cfnspec/build-tools/template/NOTICE

@@ -1,2 +1,2 @@
 AWS Cloud Development Kit (AWS CDK)
-Copyright 2018-2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+Copyright 2018-2022 Amazon.com, Inc. or its affiliates. All Rights Reserved.

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

@@ -1,6 +1,8 @@
 #!/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

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

@@ -13,51 +13,67 @@ rm -f CHANGELOG.md.new
 function update-spec() {
     local title=$1
     local url=$2
-    local target=$3
+    local targetdir=$3
     local gunzip=$4
+    local split=$5
 
-    local intermediate="$(mktemp -d)/new.json"
+    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 ${target})" ]; then
-        echo "The file ${target} has changes, revert them before cfn-update"
+    if [ -n "$(git status --porcelain ${targetdir})" ]; then
+        echo "The directory ${targetdir} has changes, revert them before cfn-update"
         exit 1
     fi
 
     echo >&2 "Downloading from ${url}..."
     if ${gunzip}; then
-        curl -sL "${url}" | gunzip - > ${intermediate}
+        curl -sL "${url}" | gunzip - > ${newspec}
     else
-        curl -sL "${url}" > ${intermediate}
+        curl -sL "${url}" > ${newspec}
     fi
 
-    echo >&2 "Sorting..."
-    sort-json ${intermediate}
+    # Calculate the old and new combined specs, so we can do a diff on the changes
+    echo >&2 "Updating source spec..."
+
+    node build-tools/patch-set.js --quiet "${targetdir}" "${oldcombined}"
+    if ${split}; then
+        node build-tools/split-spec-by-service.js "${newspec}" "${targetdir}"
+    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}" "${target}" "${intermediate}" >> CHANGELOG.md.new
-    echo "" >> CHANGELOG.md.new
+    node build-tools/spec-diff.js "${title}" "${oldcombined}" "${newcombined}" >> CHANGELOG.md.new
 
-    echo >&2 "Updating source spec..."
-    rm -f ${target}
-    cp ${intermediate} ${target}
+    echo "" >> CHANGELOG.md.new
 }
 
+# First run a build to get a complete version of the old spec
+
 update-spec \
     "CloudFormation Resource Specification" \
     "https://d1uauaxba7bl26.cloudfront.net/latest/gzip/CloudFormationResourceSpecification.json" \
-    spec-source/000_CloudFormationResourceSpecification.json \
-    true
+    spec-source/specification/000_cfn/000_official \
+    true true
 
 echo >&2 "Recording new version..."
 rm -f cfn.version
-node -p "require('${scriptdir}/../spec-source/000_CloudFormationResourceSpecification.json').ResourceSpecificationVersion" > cfn.version
+node -p "require('${scriptdir}/../spec-source/specification/000_cfn/000_official/001_Version.json').ResourceSpecificationVersion" > cfn.version
+
+
+echo >&2 "Reporting outdated specs..."
+node build-tools/report-issues spec-source/specification/000_cfn/000_official/ outdated >> CHANGELOG.md.new
 
 update-spec \
     "Serverless Application Model (SAM) Resource Specification" \
     "https://raw.githubusercontent.com/awslabs/goformation/master/generate/sam-2016-10-31.json" \
-    spec-source/000_sam.spec.json \
-    false
+    spec-source/specification/100_sam/000_official \
+    false false
 
 npm run build
 

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