aws-cdk 0.0.0

package/lib/commands/context.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.contextHandler = contextHandler;
+const chalk = require("chalk");
+const minimatch_1 = require("minimatch");
+const user_configuration_1 = require("../cli/user-configuration");
+const version = require("../cli/version");
+const logging_1 = require("../logging");
+const error_1 = require("../toolkit/error");
+const util_1 = require("../util");
+async function contextHandler(options) {
+    var _a;
+    if (options.clear) {
+        options.context.clear();
+        await options.context.save(user_configuration_1.PROJECT_CONTEXT);
+        (0, logging_1.info)('All context values cleared.');
+    }
+    else if (options.reset) {
+        invalidateContext(options.context, options.reset, (_a = options.force) !== null && _a !== void 0 ? _a : false);
+        await options.context.save(user_configuration_1.PROJECT_CONTEXT);
+    }
+    else {
+        // List -- support '--json' flag
+        if (options.json) {
+            /* istanbul ignore next */
+            const contextValues = options.context.all;
+            (0, logging_1.result)(JSON.stringify(contextValues, undefined, 2));
+        }
+        else {
+            listContext(options.context);
+        }
+    }
+    await version.displayVersionMessage();
+    return 0;
+}
+function listContext(context) {
+    const keys = contextKeys(context);
+    if (keys.length === 0) {
+        (0, logging_1.info)('This CDK application does not have any saved context values yet.');
+        (0, logging_1.info)('');
+        (0, logging_1.info)('Context will automatically be saved when you synthesize CDK apps');
+        (0, logging_1.info)('that use environment context information like AZ information, VPCs,');
+        (0, logging_1.info)('SSM parameters, and so on.');
+        return;
+    }
+    // Print config by default
+    const data_out = [[chalk.green('#'), chalk.green('Key'), chalk.green('Value')]];
+    for (const [i, key] of keys) {
+        const jsonWithoutNewlines = JSON.stringify(context.all[key], undefined, 2).replace(/\s+/g, ' ');
+        data_out.push([i, key, jsonWithoutNewlines]);
+    }
+    (0, logging_1.info)('Context found in %s:', chalk.blue(user_configuration_1.PROJECT_CONFIG));
+    (0, logging_1.info)('');
+    (0, logging_1.info)((0, util_1.renderTable)(data_out, process.stdout.columns));
+    // eslint-disable-next-line max-len
+    (0, logging_1.info)(`Run ${chalk.blue('cdk context --reset KEY_OR_NUMBER')} to remove a context key. It will be refreshed on the next CDK synthesis run.`);
+}
+function invalidateContext(context, key, force) {
+    const i = parseInt(key, 10);
+    if (`${i}` === key) {
+        // was a number and we fully parsed it.
+        key = keyByNumber(context, i);
+    }
+    // Unset!
+    if (context.has(key)) {
+        context.unset(key);
+        // check if the value was actually unset.
+        if (!context.has(key)) {
+            (0, logging_1.info)('Context value %s reset. It will be refreshed on next synthesis', chalk.blue(key));
+            return;
+        }
+        // Value must be in readonly bag
+        (0, logging_1.error)('Only context values specified in %s can be reset through the CLI', chalk.blue(user_configuration_1.PROJECT_CONTEXT));
+        if (!force) {
+            throw new error_1.ToolkitError(`Cannot reset readonly context value with key: ${key}`);
+        }
+    }
+    // check if value is expression matching keys
+    const matches = keysByExpression(context, key);
+    if (matches.length > 0) {
+        matches.forEach((match) => {
+            context.unset(match);
+        });
+        const { unset, readonly } = getUnsetAndReadonly(context, matches);
+        // output the reset values
+        printUnset(unset);
+        // warn about values not reset
+        printReadonly(readonly);
+        // throw when none of the matches were reset
+        if (!force && unset.length === 0) {
+            throw new error_1.ToolkitError('None of the matched context values could be reset');
+        }
+        return;
+    }
+    if (!force) {
+        throw new error_1.ToolkitError(`No context value matching key: ${key}`);
+    }
+}
+function printUnset(unset) {
+    if (unset.length === 0)
+        return;
+    (0, logging_1.info)('The following matched context values reset. They will be refreshed on next synthesis');
+    unset.forEach((match) => {
+        (0, logging_1.info)('  %s', match);
+    });
+}
+function printReadonly(readonly) {
+    if (readonly.length === 0)
+        return;
+    (0, logging_1.warning)('The following matched context values could not be reset through the CLI');
+    readonly.forEach((match) => {
+        (0, logging_1.info)('  %s', match);
+    });
+    (0, logging_1.info)('');
+    (0, logging_1.info)('This usually means they are configured in %s or %s', chalk.blue(user_configuration_1.PROJECT_CONFIG), chalk.blue(user_configuration_1.USER_DEFAULTS));
+}
+function keysByExpression(context, expression) {
+    return context.keys.filter(minimatch_1.minimatch.filter(expression));
+}
+function getUnsetAndReadonly(context, matches) {
+    return matches.reduce((acc, match) => {
+        if (context.has(match)) {
+            acc.readonly.push(match);
+        }
+        else {
+            acc.unset.push(match);
+        }
+        return acc;
+    }, { unset: [], readonly: [] });
+}
+function keyByNumber(context, n) {
+    for (const [i, key] of contextKeys(context)) {
+        if (n === i) {
+            return key;
+        }
+    }
+    throw new error_1.ToolkitError(`No context key with number: ${n}`);
+}
+/**
+ * Return enumerated keys in a definitive order
+ */
+function contextKeys(context) {
+    const keys = context.keys;
+    keys.sort();
+    return enumerate1(keys);
+}
+function enumerate1(xs) {
+    const ret = new Array();
+    let i = 1;
+    for (const x of xs) {
+        ret.push([i, x]);
+        i += 1;
+    }
+    return ret;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"context.js","sourceRoot":"","sources":["context.ts"],"names":[],"mappings":";;AA+CA,wCAqBC;AApED,+BAA+B;AAC/B,yCAAsC;AAEtC,kEAA2F;AAC3F,0CAA0C;AAC1C,wCAA0D;AAC1D,4CAAgD;AAChD,kCAAsC;AAwC/B,KAAK,UAAU,cAAc,CAAC,OAAuB;;IAC1D,IAAI,OAAO,CAAC,KAAK,EAAE,CAAC;QAClB,OAAO,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC;QACxB,MAAM,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,oCAAe,CAAC,CAAC;QAC5C,IAAA,cAAI,EAAC,6BAA6B,CAAC,CAAC;IACtC,CAAC;SAAM,IAAI,OAAO,CAAC,KAAK,EAAE,CAAC;QACzB,iBAAiB,CAAC,OAAO,CAAC,OAAO,EAAE,OAAO,CAAC,KAAK,EAAE,MAAA,OAAO,CAAC,KAAK,mCAAI,KAAK,CAAC,CAAC;QAC1E,MAAM,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,oCAAe,CAAC,CAAC;IAC9C,CAAC;SAAM,CAAC;QACN,gCAAgC;QAChC,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC;YACjB,0BAA0B;YAC1B,MAAM,aAAa,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC;YAC1C,IAAA,gBAAM,EAAC,IAAI,CAAC,SAAS,CAAC,aAAa,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC,CAAC;QACtD,CAAC;aAAM,CAAC;YACN,WAAW,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;QAC/B,CAAC;IACH,CAAC;IACD,MAAM,OAAO,CAAC,qBAAqB,EAAE,CAAC;IAEtC,OAAO,CAAC,CAAC;AACX,CAAC;AAED,SAAS,WAAW,CAAC,OAAgB;IACnC,MAAM,IAAI,GAAG,WAAW,CAAC,OAAO,CAAC,CAAC;IAElC,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACtB,IAAA,cAAI,EAAC,kEAAkE,CAAC,CAAC;QACzE,IAAA,cAAI,EAAC,EAAE,CAAC,CAAC;QACT,IAAA,cAAI,EAAC,kEAAkE,CAAC,CAAC;QACzE,IAAA,cAAI,EAAC,qEAAqE,CAAC,CAAC;QAC5E,IAAA,cAAI,EAAC,4BAA4B,CAAC,CAAC;QAEnC,OAAO;IACT,CAAC;IAED,0BAA0B;IAC1B,MAAM,QAAQ,GAAU,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;IACvF,KAAK,MAAM,CAAC,CAAC,EAAE,GAAG,CAAC,IAAI,IAAI,EAAE,CAAC;QAC5B,MAAM,mBAAmB,GAAG,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QAChG,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,mBAAmB,CAAC,CAAC,CAAC;IAC/C,CAAC;IACD,IAAA,cAAI,EAAC,sBAAsB,EAAE,KAAK,CAAC,IAAI,CAAC,mCAAc,CAAC,CAAC,CAAC;IACzD,IAAA,cAAI,EAAC,EAAE,CAAC,CAAC;IACT,IAAA,cAAI,EAAC,IAAA,kBAAW,EAAC,QAAQ,EAAE,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC;IAEpD,mCAAmC;IACnC,IAAA,cAAI,EAAC,OAAO,KAAK,CAAC,IAAI,CAAC,mCAAmC,CAAC,+EAA+E,CAAC,CAAC;AAC9I,CAAC;AAED,SAAS,iBAAiB,CAAC,OAAgB,EAAE,GAAW,EAAE,KAAc;IACtE,MAAM,CAAC,GAAG,QAAQ,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;IAC5B,IAAI,GAAG,CAAC,EAAE,KAAK,GAAG,EAAE,CAAC;QACnB,uCAAuC;QACvC,GAAG,GAAG,WAAW,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;IAChC,CAAC;IACD,SAAS;IACT,IAAI,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;QACrB,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QACnB,yCAAyC;QACzC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;YACtB,IAAA,cAAI,EAAC,gEAAgE,EAAE,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;YACxF,OAAO;QACT,CAAC;QAED,gCAAgC;QAChC,IAAA,eAAK,EAAC,kEAAkE,EAAE,KAAK,CAAC,IAAI,CAAC,oCAAe,CAAC,CAAC,CAAC;QACvG,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,MAAM,IAAI,oBAAY,CAAC,iDAAiD,GAAG,EAAE,CAAC,CAAC;QACjF,CAAC;IACH,CAAC;IAED,6CAA6C;IAC7C,MAAM,OAAO,GAAG,gBAAgB,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC;IAE/C,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAEvB,OAAO,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE;YACxB,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QACvB,CAAC,CAAC,CAAC;QAEH,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,GAAG,mBAAmB,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;QAElE,0BAA0B;QAC1B,UAAU,CAAC,KAAK,CAAC,CAAC;QAElB,8BAA8B;QAC9B,aAAa,CAAC,QAAQ,CAAC,CAAC;QAExB,4CAA4C;QAC5C,IAAI,CAAC,KAAK,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACjC,MAAM,IAAI,oBAAY,CAAC,mDAAmD,CAAC,CAAC;QAC9E,CAAC;QACD,OAAO;IACT,CAAC;IACD,IAAI,CAAC,KAAK,EAAE,CAAC;QACX,MAAM,IAAI,oBAAY,CAAC,kCAAkC,GAAG,EAAE,CAAC,CAAC;IAClE,CAAC;AACH,CAAC;AAED,SAAS,UAAU,CAAC,KAAe;IACjC,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO;IAC/B,IAAA,cAAI,EAAC,sFAAsF,CAAC,CAAC;IAC7F,KAAK,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE;QACtB,IAAA,cAAI,EAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IACtB,CAAC,CAAC,CAAC;AACL,CAAC;AAED,SAAS,aAAa,CAAC,QAAkB;IACvC,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO;IAClC,IAAA,iBAAO,EAAC,yEAAyE,CAAC,CAAC;IACnF,QAAQ,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE;QACzB,IAAA,cAAI,EAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IACtB,CAAC,CAAC,CAAC;IACH,IAAA,cAAI,EAAC,EAAE,CAAC,CAAC;IACT,IAAA,cAAI,EAAC,oDAAoD,EAAE,KAAK,CAAC,IAAI,CAAC,mCAAc,CAAC,EAAE,KAAK,CAAC,IAAI,CAAC,kCAAa,CAAC,CAAC,CAAC;AACpH,CAAC;AAED,SAAS,gBAAgB,CAAC,OAAgB,EAAE,UAAkB;IAC5D,OAAO,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,qBAAS,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC;AAC3D,CAAC;AAED,SAAS,mBAAmB,CAAC,OAAgB,EAAE,OAAiB;IAC9D,OAAO,OAAO,CAAC,MAAM,CAA0C,CAAC,GAAG,EAAE,KAAK,EAAE,EAAE;QAC5E,IAAI,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;YACvB,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC3B,CAAC;aAAM,CAAC;YACN,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACxB,CAAC;QACD,OAAO,GAAG,CAAC;IACb,CAAC,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC,CAAC;AAClC,CAAC;AAED,SAAS,WAAW,CAAC,OAAgB,EAAE,CAAS;IAC9C,KAAK,MAAM,CAAC,CAAC,EAAE,GAAG,CAAC,IAAI,WAAW,CAAC,OAAO,CAAC,EAAE,CAAC;QAC5C,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;YACZ,OAAO,GAAG,CAAC;QACb,CAAC;IACH,CAAC;IACD,MAAM,IAAI,oBAAY,CAAC,+BAA+B,CAAC,EAAE,CAAC,CAAC;AAC7D,CAAC;AAED;;GAEG;AACH,SAAS,WAAW,CAAC,OAAgB;IACnC,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAC1B,IAAI,CAAC,IAAI,EAAE,CAAC;IACZ,OAAO,UAAU,CAAC,IAAI,CAAC,CAAC;AAC1B,CAAC;AAED,SAAS,UAAU,CAAI,EAAO;IAC5B,MAAM,GAAG,GAAG,IAAI,KAAK,EAAe,CAAC;IACrC,IAAI,CAAC,GAAG,CAAC,CAAC;IACV,KAAK,MAAM,CAAC,IAAI,EAAE,EAAE,CAAC;QACnB,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;QACjB,CAAC,IAAI,CAAC,CAAC;IACT,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC","sourcesContent":["import * as chalk from 'chalk';\nimport { minimatch } from 'minimatch';\nimport { Context } from '../api/context';\nimport { PROJECT_CONFIG, PROJECT_CONTEXT, USER_DEFAULTS } from '../cli/user-configuration';\nimport * as version from '../cli/version';\nimport { error, warning, info, result } from '../logging';\nimport { ToolkitError } from '../toolkit/error';\nimport { renderTable } from '../util';\n\n/**\n * Options for the context command\n */\nexport interface ContextOptions {\n  /**\n   * The context object sourced from all context locations\n   */\n  context: Context;\n\n  /**\n   * The context key (or its index) to reset\n   *\n   * @default undefined\n   */\n  reset?: string;\n\n  /**\n   * Ignore missing key error\n   *\n   * @default false\n   */\n  force?: boolean;\n\n  /**\n   * Clear all context\n   *\n   * @default false\n   */\n  clear?: boolean;\n\n  /**\n   * Use JSON output instead of YAML when templates are printed to STDOUT\n   *\n   * @default false\n   */\n  json?: boolean;\n}\n\nexport async function contextHandler(options: ContextOptions): Promise<number> {\n  if (options.clear) {\n    options.context.clear();\n    await options.context.save(PROJECT_CONTEXT);\n    info('All context values cleared.');\n  } else if (options.reset) {\n    invalidateContext(options.context, options.reset, options.force ?? false);\n    await options.context.save(PROJECT_CONTEXT);\n  } else {\n    // List -- support '--json' flag\n    if (options.json) {\n      /* istanbul ignore next */\n      const contextValues = options.context.all;\n      result(JSON.stringify(contextValues, undefined, 2));\n    } else {\n      listContext(options.context);\n    }\n  }\n  await version.displayVersionMessage();\n\n  return 0;\n}\n\nfunction listContext(context: Context) {\n  const keys = contextKeys(context);\n\n  if (keys.length === 0) {\n    info('This CDK application does not have any saved context values yet.');\n    info('');\n    info('Context will automatically be saved when you synthesize CDK apps');\n    info('that use environment context information like AZ information, VPCs,');\n    info('SSM parameters, and so on.');\n\n    return;\n  }\n\n  // Print config by default\n  const data_out: any[] = [[chalk.green('#'), chalk.green('Key'), chalk.green('Value')]];\n  for (const [i, key] of keys) {\n    const jsonWithoutNewlines = JSON.stringify(context.all[key], undefined, 2).replace(/\\s+/g, ' ');\n    data_out.push([i, key, jsonWithoutNewlines]);\n  }\n  info('Context found in %s:', chalk.blue(PROJECT_CONFIG));\n  info('');\n  info(renderTable(data_out, process.stdout.columns));\n\n  // eslint-disable-next-line max-len\n  info(`Run ${chalk.blue('cdk context --reset KEY_OR_NUMBER')} to remove a context key. It will be refreshed on the next CDK synthesis run.`);\n}\n\nfunction invalidateContext(context: Context, key: string, force: boolean) {\n  const i = parseInt(key, 10);\n  if (`${i}` === key) {\n    // was a number and we fully parsed it.\n    key = keyByNumber(context, i);\n  }\n  // Unset!\n  if (context.has(key)) {\n    context.unset(key);\n    // check if the value was actually unset.\n    if (!context.has(key)) {\n      info('Context value %s reset. It will be refreshed on next synthesis', chalk.blue(key));\n      return;\n    }\n\n    // Value must be in readonly bag\n    error('Only context values specified in %s can be reset through the CLI', chalk.blue(PROJECT_CONTEXT));\n    if (!force) {\n      throw new ToolkitError(`Cannot reset readonly context value with key: ${key}`);\n    }\n  }\n\n  // check if value is expression matching keys\n  const matches = keysByExpression(context, key);\n\n  if (matches.length > 0) {\n\n    matches.forEach((match) => {\n      context.unset(match);\n    });\n\n    const { unset, readonly } = getUnsetAndReadonly(context, matches);\n\n    // output the reset values\n    printUnset(unset);\n\n    // warn about values not reset\n    printReadonly(readonly);\n\n    // throw when none of the matches were reset\n    if (!force && unset.length === 0) {\n      throw new ToolkitError('None of the matched context values could be reset');\n    }\n    return;\n  }\n  if (!force) {\n    throw new ToolkitError(`No context value matching key: ${key}`);\n  }\n}\n\nfunction printUnset(unset: string[]) {\n  if (unset.length === 0) return;\n  info('The following matched context values reset. They will be refreshed on next synthesis');\n  unset.forEach((match) => {\n    info('  %s', match);\n  });\n}\n\nfunction printReadonly(readonly: string[]) {\n  if (readonly.length === 0) return;\n  warning('The following matched context values could not be reset through the CLI');\n  readonly.forEach((match) => {\n    info('  %s', match);\n  });\n  info('');\n  info('This usually means they are configured in %s or %s', chalk.blue(PROJECT_CONFIG), chalk.blue(USER_DEFAULTS));\n}\n\nfunction keysByExpression(context: Context, expression: string) {\n  return context.keys.filter(minimatch.filter(expression));\n}\n\nfunction getUnsetAndReadonly(context: Context, matches: string[]) {\n  return matches.reduce<{ unset: string[]; readonly: string[] }>((acc, match) => {\n    if (context.has(match)) {\n      acc.readonly.push(match);\n    } else {\n      acc.unset.push(match);\n    }\n    return acc;\n  }, { unset: [], readonly: [] });\n}\n\nfunction keyByNumber(context: Context, n: number) {\n  for (const [i, key] of contextKeys(context)) {\n    if (n === i) {\n      return key;\n    }\n  }\n  throw new ToolkitError(`No context key with number: ${n}`);\n}\n\n/**\n * Return enumerated keys in a definitive order\n */\nfunction contextKeys(context: Context): [number, string][] {\n  const keys = context.keys;\n  keys.sort();\n  return enumerate1(keys);\n}\n\nfunction enumerate1<T>(xs: T[]): Array<[number, T]> {\n  const ret = new Array<[number, T]>();\n  let i = 1;\n  for (const x of xs) {\n    ret.push([i, x]);\n    i += 1;\n  }\n  return ret;\n}\n"]}

package/lib/commands/docs.d.ts

@@ -0,0 +1,13 @@
+export declare const command = "docs";
+export declare const describe = "Opens the reference documentation in a browser";
+export declare const aliases: string[];
+/**
+ * Options for the docs command
+ */
+export interface DocsOptions {
+    /**
+     * The command to use to open the browser
+     */
+    browser: string;
+}
+export declare function docs(options: DocsOptions): Promise<number>;

package/lib/commands/docs.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aliases = exports.describe = exports.command = void 0;
+exports.docs = docs;
+const childProcess = require("child_process");
+const chalk = require("chalk");
+const logging_1 = require("../../lib/logging");
+exports.command = 'docs';
+exports.describe = 'Opens the reference documentation in a browser';
+exports.aliases = ['doc'];
+async function docs(options) {
+    const url = 'https://docs.aws.amazon.com/cdk/api/v2/';
+    (0, logging_1.info)(chalk.green(url));
+    const browserCommand = (options.browser).replace(/%u/g, url);
+    (0, logging_1.debug)(`Opening documentation ${chalk.green(browserCommand)}`);
+    return new Promise((resolve, _reject) => {
+        childProcess.exec(browserCommand, (err, stdout, stderr) => {
+            if (err) {
+                (0, logging_1.debug)(`An error occurred when trying to open a browser: ${err.stack || err.message}`);
+                return resolve(0);
+            }
+            if (stdout) {
+                (0, logging_1.debug)(stdout);
+            }
+            if (stderr) {
+                (0, logging_1.warning)(stderr);
+            }
+            resolve(0);
+        });
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/commands/doctor.d.ts

@@ -0,0 +1 @@
+export declare function doctor(): Promise<number>;

package/lib/commands/doctor.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.doctor = doctor;
+const process = require("process");
+const cxapi = require("@aws-cdk/cx-api");
+const chalk = require("chalk");
+const logging_1 = require("../../lib/logging");
+const version = require("../cli/version");
+async function doctor() {
+    let exitStatus = 0;
+    for (const verification of verifications) {
+        if (!await verification()) {
+            exitStatus = -1;
+        }
+    }
+    await version.displayVersionMessage();
+    return exitStatus;
+}
+const verifications = [
+    displayVersionInformation,
+    displayAwsEnvironmentVariables,
+    displayCdkEnvironmentVariables,
+];
+// ### Verifications ###
+function displayVersionInformation() {
+    (0, logging_1.info)(`ℹ️ CDK Version: ${chalk.green(version.DISPLAY_VERSION)}`);
+    return true;
+}
+function displayAwsEnvironmentVariables() {
+    const keys = Object.keys(process.env).filter(s => s.startsWith('AWS_'));
+    if (keys.length === 0) {
+        (0, logging_1.info)('ℹ️ No AWS environment variables');
+        return true;
+    }
+    (0, logging_1.info)('ℹ️ AWS environment variables:');
+    for (const key of keys) {
+        (0, logging_1.info)(`  - ${chalk.blue(key)} = ${chalk.green(anonymizeAwsVariable(key, process.env[key]))}`);
+    }
+    return true;
+}
+function displayCdkEnvironmentVariables() {
+    const keys = Object.keys(process.env).filter(s => s.startsWith('CDK_'));
+    if (keys.length === 0) {
+        (0, logging_1.info)('ℹ️ No CDK environment variables');
+        return true;
+    }
+    (0, logging_1.info)('ℹ️ CDK environment variables:');
+    let healthy = true;
+    for (const key of keys.sort()) {
+        if (key === cxapi.CONTEXT_ENV || key === cxapi.CONTEXT_OVERFLOW_LOCATION_ENV || key === cxapi.OUTDIR_ENV) {
+            (0, logging_1.info)(`  - ${chalk.red(key)} = ${chalk.green(process.env[key])} (⚠️ reserved for use by the CDK toolkit)`);
+            healthy = false;
+        }
+        else {
+            (0, logging_1.info)(`  - ${chalk.blue(key)} = ${chalk.green(process.env[key])}`);
+        }
+    }
+    return healthy;
+}
+function anonymizeAwsVariable(name, value) {
+    if (name === 'AWS_ACCESS_KEY_ID') {
+        return value.slice(0, 4) + '<redacted>';
+    } // Show ASIA/AKIA key type, but hide identifier
+    if (name === 'AWS_SECRET_ACCESS_KEY' || name === 'AWS_SESSION_TOKEN' || name === 'AWS_SECURITY_TOKEN') {
+        return '<redacted>';
+    }
+    return value;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/commands/migrate.d.ts

@@ -0,0 +1,327 @@
+import { Environment } from '@aws-cdk/cx-api';
+import type { DescribeGeneratedTemplateCommandOutput, DescribeResourceScanCommandOutput, GetGeneratedTemplateCommandOutput, ResourceDefinition, ResourceDetail, ResourceIdentifierSummary, ResourceScanSummary, ScannedResource, ScannedResourceIdentifier } from '@aws-sdk/client-cloudformation';
+import type { ICloudFormationClient, SdkProvider } from '../api/aws-auth';
+/**
+ * Generates a CDK app from a yaml or json template.
+ *
+ * @param stackName The name to assign to the stack in the generated app
+ * @param stack The yaml or json template for the stack
+ * @param language The language to generate the CDK app in
+ * @param outputPath The path at which to generate the CDK app
+ */
+export declare function generateCdkApp(stackName: string, stack: string, language: string, outputPath?: string, compress?: boolean): Promise<void>;
+/**
+ * Generates a CDK stack file.
+ * @param template The template to translate into a CDK stack
+ * @param stackName The name to assign to the stack
+ * @param language The language to generate the stack in
+ * @returns A string representation of a CDK stack file
+ */
+export declare function generateStack(template: string, stackName: string, language: string): string;
+/**
+ * Reads and returns a stack template from a local path.
+ *
+ * @param inputPath The location of the template
+ * @returns A string representation of the template if present, otherwise undefined
+ */
+export declare function readFromPath(inputPath: string): string;
+/**
+ * Reads and returns a stack template from a deployed CloudFormation stack.
+ *
+ * @param stackName The name of the stack
+ * @param sdkProvider The sdk provider for making CloudFormation calls
+ * @param environment The account and region where the stack is deployed
+ * @returns A string representation of the template if present, otherwise undefined
+ */
+export declare function readFromStack(stackName: string, sdkProvider: SdkProvider, environment: Environment): Promise<string | undefined>;
+/**
+ * Takes in a stack name and account and region and returns a generated cloudformation template using the cloudformation
+ * template generator.
+ *
+ * @param GenerateTemplateOptions An object containing the stack name, filters, sdkProvider, environment, and newScan flag
+ * @returns a generated cloudformation template
+ */
+export declare function generateTemplate(options: GenerateTemplateOptions): Promise<GenerateTemplateOutput>;
+/**
+ * Takes a list of any type and breaks it up into chunks of a specified size.
+ *
+ * @param list The list to break up
+ * @param chunkSize The size of each chunk
+ * @returns A list of lists of the specified size
+ */
+export declare function chunks(list: any[], chunkSize: number): any[][];
+/**
+ * Sets the account and region for making CloudFormation calls.
+ * @param account The account to use
+ * @param region The region to use
+ * @returns The environment object
+ */
+export declare function setEnvironment(account?: string, region?: string): Environment;
+/**
+ * Enum for the source options for the template
+ */
+export declare enum TemplateSourceOptions {
+    PATH = "path",
+    STACK = "stack",
+    SCAN = "scan"
+}
+/**
+ * An object representing the source of a template.
+ */
+type TemplateSource = {
+    source: TemplateSourceOptions.SCAN;
+} | {
+    source: TemplateSourceOptions.PATH;
+    templatePath: string;
+} | {
+    source: TemplateSourceOptions.STACK;
+    stackName: string;
+};
+/**
+ * Enum for the status of a resource scan
+ */
+export declare enum ScanStatus {
+    IN_PROGRESS = "IN_PROGRESS",
+    COMPLETE = "COMPLETE",
+    FAILED = "FAILED"
+}
+export declare enum FilterType {
+    RESOURCE_IDENTIFIER = "resource-identifier",
+    RESOURCE_TYPE_PREFIX = "resource-type-prefix",
+    TAG_KEY = "tag-key",
+    TAG_VALUE = "tag-value"
+}
+/**
+ * Validates that exactly one source option has been provided.
+ * @param fromPath The content of the flag `--from-path`
+ * @param fromStack the content of the flag `--from-stack`
+ */
+export declare function parseSourceOptions(fromPath?: string, fromStack?: boolean, stackName?: string): TemplateSource;
+/**
+ * Takes a scan id and maintains a progress bar to display the progress of a scan to the user.
+ *
+ * @param scanId A string representing the scan id
+ * @param cloudFormation The CloudFormation sdk client to use
+ */
+export declare function scanProgressBar(scanId: string, cfn: CfnTemplateGeneratorProvider): Promise<void>;
+/**
+ * Prints a progress bar to the console. To be used in a while loop to show progress of a long running task.
+ * The progress bar deletes the current line on the console and rewrites it with the progress amount.
+ *
+ * @param width The width of the progress bar
+ * @param progress The current progress to display as a percentage of 100
+ */
+export declare function printBar(width: number, progress: number): void;
+/**
+ * Prints a message to the console with a series periods appended to it. To be used in a while loop to show progress of a long running task.
+ * The message deletes the current line and rewrites it several times to display 1-3 periods to show the user that the task is still running.
+ *
+ * @param message The message to display
+ * @param timeoutx4 The amount of time to wait before printing the next period
+ */
+export declare function printDots(message: string, timeoutx4: number): Promise<void>;
+/**
+ * Rewrites the current line on the console and writes a new message to it.
+ * This is a helper funciton for printDots and printBar.
+ *
+ * @param message The message to display
+ */
+export declare function rewriteLine(message: string): void;
+/**
+ * Prints the time difference between two dates in days, hours, and minutes.
+ *
+ * @param time1 The first date to compare
+ * @param time2 The second date to compare
+ */
+export declare function displayTimeDiff(time1: Date, time2: Date): void;
+/**
+ * Writes a migrate.json file to the output directory.
+ *
+ * @param outputPath The path to write the migrate.json file to
+ * @param stackName The name of the stack
+ * @param generatedOutput The output of the template generator
+ */
+export declare function writeMigrateJsonFile(outputPath: string | undefined, stackName: string, migrateJson: MigrateJsonFormat): void;
+/**
+ * Takes a string representing the from-scan flag and returns a FromScan enum value.
+ *
+ * @param scanType A string representing the from-scan flag
+ * @returns A FromScan enum value
+ */
+export declare function getMigrateScanType(scanType: string): FromScan;
+/**
+ * Takes a generatedTemplateOutput objct and returns a boolean representing whether there are any warnings on any rescources.
+ *
+ * @param generatedTemplateOutput A GenerateTemplateOutput object
+ * @returns A boolean representing whether there are any warnings on any rescources
+ */
+export declare function isThereAWarning(generatedTemplateOutput: GenerateTemplateOutput): boolean;
+/**
+ * Builds the GenerateTemplateOutput object from the DescribeGeneratedTemplateOutput and the template body.
+ *
+ * @param generatedTemplateSummary The output of the describe generated template call
+ * @param templateBody The body of the generated template
+ * @returns A GenerateTemplateOutput object
+ */
+export declare function buildGenertedTemplateOutput(generatedTemplateSummary: DescribeGeneratedTemplateCommandOutput, templateBody: string, source: string): GenerateTemplateOutput;
+/**
+ * Builds a CloudFormation sdk client for making requests with the CFN template generator.
+ *
+ * @param sdkProvider The sdk provider for making CloudFormation calls
+ * @param environment The account and region where the stack is deployed
+ * @returns A CloudFormation sdk client
+ */
+export declare function buildCfnClient(sdkProvider: SdkProvider, environment: Environment): Promise<ICloudFormationClient>;
+/**
+ * Appends a list of warnings to a readme file.
+ *
+ * @param filepath The path to the readme file
+ * @param resources A list of resources to append warnings for
+ */
+export declare function appendWarningsToReadme(filepath: string, resources: ResourceDetail[]): void;
+/**
+ * Class for making CloudFormation template generator calls
+ */
+export declare class CfnTemplateGeneratorProvider {
+    private cfn;
+    constructor(cfn: ICloudFormationClient);
+    checkForResourceScan(resourceScanSummaries: ResourceScanSummary[] | undefined, options: GenerateTemplateOptions, clientRequestToken: string): Promise<void>;
+    /**
+     * Retrieves a tokenized list of resources and their associated scan. If a token is present the function
+     * will loop through all pages and combine them into a single list of ScannedRelatedResources
+     *
+     * @param scanId scan id for the to list resources for
+     * @param resources A list of resources to find related resources for
+     */
+    getResourceScanRelatedResources(scanId: string, resources: ScannedResource[]): Promise<ScannedResourceIdentifier[]>;
+    /**
+     * Kicks off a scan of a customers account, returning the scan id. A scan can take
+     * 10 minutes or longer to complete. However this will return a scan id as soon as
+     * the scan has begun.
+     *
+     * @returns A string representing the scan id
+     */
+    startResourceScan(requestToken: string): Promise<string | undefined>;
+    /**
+     * Gets the most recent scans a customer has completed
+     *
+     * @returns a list of resource scan summaries
+     */
+    listResourceScans(): Promise<import("@aws-sdk/client-cloudformation").ListResourceScansCommandOutput>;
+    /**
+     * Retrieves a tokenized list of resources from a resource scan. If a token is present, this function
+     * will loop through all pages and combine them into a single list of ScannedResource[].
+     * Additionally will apply any filters provided by the customer.
+     *
+     * @param scanId scan id for the to list resources for
+     * @param filters a string of filters in the format of key1=value1,key2=value2
+     * @returns a combined list of all resources from the scan
+     */
+    listResourceScanResources(scanId: string, filters?: string[]): Promise<ScannedResourceIdentifier[]>;
+    /**
+     * Retrieves information about a resource scan.
+     *
+     * @param scanId scan id for the to list resources for
+     * @returns information about the scan
+     */
+    describeResourceScan(scanId: string): Promise<DescribeResourceScanCommandOutput>;
+    /**
+     * Describes the current status of the template being generated.
+     *
+     * @param templateId A string representing the template id
+     * @returns DescribeGeneratedTemplateOutput an object containing the template status and results
+     */
+    describeGeneratedTemplate(templateId: string): Promise<DescribeGeneratedTemplateCommandOutput>;
+    /**
+     * Retrieves a completed generated cloudformation template from the template generator.
+     *
+     * @param templateId A string representing the template id
+     * @param cloudFormation The CloudFormation sdk client to use
+     * @returns DescribeGeneratedTemplateOutput an object containing the template status and body
+     */
+    getGeneratedTemplate(templateId: string): Promise<GetGeneratedTemplateCommandOutput>;
+    /**
+     * Kicks off a template generation for a set of resources.
+     *
+     * @param stackName The name of the stack
+     * @param resources A list of resources to generate the template from
+     * @returns CreateGeneratedTemplateOutput an object containing the template arn to query on later
+     */
+    createGeneratedTemplate(stackName: string, resources: ResourceDefinition[]): Promise<import("@aws-sdk/client-cloudformation").CreateGeneratedTemplateCommandOutput>;
+    /**
+     * Deletes a generated template from the template generator.
+     *
+     * @param templateArn The arn of the template to delete
+     * @returns A promise that resolves when the template has been deleted
+     */
+    deleteGeneratedTemplate(templateArn: string): Promise<void>;
+}
+/**
+ * The possible ways to choose a scan to generate a CDK application from
+ */
+export declare enum FromScan {
+    /**
+     * Initiate a new resource scan to build the CDK application from.
+     */
+    NEW = 0,
+    /**
+     * Use the last successful scan to build the CDK application from. Will fail if no scan is found.
+     */
+    MOST_RECENT = 1,
+    /**
+     * Starts a scan if none exists, otherwise uses the most recent successful scan to build the CDK application from.
+     */
+    DEFAULT = 2
+}
+/**
+ * Interface for the options object passed to the generateTemplate function
+ *
+ * @param stackName The name of the stack
+ * @param filters A list of filters to apply to the scan
+ * @param fromScan An enum value specifying whether a new scan should be started or the most recent successful scan should be used
+ * @param sdkProvider The sdk provider for making CloudFormation calls
+ * @param environment The account and region where the stack is deployed
+ */
+export interface GenerateTemplateOptions {
+    stackName: string;
+    filters?: string[];
+    fromScan?: FromScan;
+    sdkProvider: SdkProvider;
+    environment: Environment;
+}
+/**
+ * Interface for the output of the generateTemplate function
+ *
+ * @param migrateJson The generated Migrate.json file
+ * @param resources The generated template
+ */
+export interface GenerateTemplateOutput {
+    migrateJson: MigrateJsonFormat;
+    resources?: ResourceDetail[];
+    templateId?: string;
+}
+/**
+ * Interface defining the format of the generated Migrate.json file
+ *
+ * @param TemplateBody The generated template
+ * @param Source The source of the template
+ * @param Resources A list of resources that were used to generate the template
+ */
+export interface MigrateJsonFormat {
+    templateBody: string;
+    source: string;
+    resources?: GeneratedResourceImportIdentifier[];
+}
+/**
+ * Interface representing the format of a resource identifier required for resource import
+ *
+ * @param ResourceType The type of resource
+ * @param LogicalResourceId The logical id of the resource
+ * @param ResourceIdentifier The resource identifier of the resource
+ */
+export interface GeneratedResourceImportIdentifier {
+    ResourceType: string;
+    LogicalResourceId: string;
+    ResourceIdentifier: ResourceIdentifierSummary;
+}
+export {};