ness
Version:
✪ No-effort static sites deployed to your AWS account.
452 lines • 49.6 kB
JavaScript
"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.ParameterValues = exports.TemplateParameters = exports.stabilizeStack = exports.waitForStackDeploy = exports.waitForStackDelete = exports.changeSetHasNoChanges = exports.waitForChangeSet = exports.CloudFormationStack = exports.toYAML = void 0;
const stack_status_1 = require("./stack-status");
const yaml = __importStar(require("./yaml"));
/**
* Stringify to YAML
*/
function toYAML(obj) {
return yaml.serialize(obj);
}
exports.toYAML = toYAML;
/**
* Parse either YAML or JSON
*/
function deserializeStructure(str) {
try {
return yaml.deserialize(str);
}
catch (e) {
return JSON.parse(str);
}
}
/**
* Represents an (existing) Stack in CloudFormation
*
* Bundle and cache some information that we need during deployment (so we don't have to make
* repeated calls to CloudFormation).
*/
class CloudFormationStack {
constructor(cfn, stackName, stack) {
this.cfn = cfn;
this.stackName = stackName;
this.stack = stack;
}
static async lookup(cfn, stackName) {
try {
const response = await cfn.describeStacks({ StackName: stackName });
return new CloudFormationStack(cfn, stackName, response.Stacks && response.Stacks[0]);
}
catch (e) {
if (e instanceof Error) {
if (e.message === `Stack with id ${stackName} does not exist`) {
return new CloudFormationStack(cfn, stackName, undefined);
}
}
throw e;
}
}
/**
* Return a copy of the given stack that does not exist
*
* It's a little silly that it needs arguments to do that, but there we go.
*/
static doesNotExist(cfn, stackName) {
return new CloudFormationStack(cfn, stackName);
}
/**
* From static information (for testing)
*/
static fromStaticInformation(cfn, stackName, stack) {
return new CloudFormationStack(cfn, stackName, stack);
}
/**
* Retrieve the stack's deployed template
*
* Cached, so will only be retrieved once. Will return an empty
* structure if the stack does not exist.
*/
async template() {
if (!this.exists) {
return {};
}
if (this._template === undefined) {
const response = await this.cfn.getTemplate({
StackName: this.stackName,
TemplateStage: 'Original',
});
this._template = (response.TemplateBody && deserializeStructure(response.TemplateBody)) || {};
}
return this._template;
}
/**
* Whether the stack exists
*/
get exists() {
return this.stack !== undefined;
}
/**
* The stack's ID
*
* Throws if the stack doesn't exist.
*/
get stackId() {
this.assertExists();
return this.stack.StackId;
}
/**
* The stack's current outputs
*
* Empty object if the stack doesn't exist
*/
get outputs() {
if (!this.exists) {
return {};
}
const result = {};
(this.stack.Outputs || []).forEach((output) => {
result[output.OutputKey] = output.OutputValue;
});
return result;
}
/**
* The stack's status
*
* Special status NOT_FOUND if the stack does not exist.
*/
get stackStatus() {
if (!this.exists) {
return new stack_status_1.StackStatus('NOT_FOUND', 'Stack not found during lookup');
}
return stack_status_1.StackStatus.fromStackDescription(this.stack);
}
/**
* The stack's current tags
*
* Empty list of the stack does not exist
*/
get tags() {
var _a;
return ((_a = this.stack) === null || _a === void 0 ? void 0 : _a.Tags) || [];
}
/**
* Return the names of all current parameters to the stack
*
* Empty list if the stack does not exist.
*/
get parameterNames() {
return Object.keys(this.parameters);
}
/**
* Return the names and values of all current parameters to the stack
*
* Empty object if the stack does not exist.
*/
get parameters() {
var _a;
if (!this.exists) {
return {};
}
const ret = {};
for (const param of (_a = this.stack.Parameters) !== null && _a !== void 0 ? _a : []) {
ret[param.ParameterKey] = param.ParameterValue;
}
return ret;
}
/**
* Return the termination protection of the stack
*/
get terminationProtection() {
var _a;
return (_a = this.stack) === null || _a === void 0 ? void 0 : _a.EnableTerminationProtection;
}
assertExists() {
if (!this.exists) {
throw new Error(`No stack named '${this.stackName}'`);
}
}
}
exports.CloudFormationStack = CloudFormationStack;
/**
* Describe a changeset in CloudFormation, regardless of its current state.
*
* @param cfn a CloudFormation client
* @param stackName the name of the Stack the ChangeSet belongs to
* @param changeSetName the name of the ChangeSet
*
* @returns CloudFormation information about the ChangeSet
*/
async function describeChangeSet(cfn, stackName, changeSetName) {
const response = await cfn.describeChangeSet({ StackName: stackName, ChangeSetName: changeSetName });
return response;
}
/**
* Waits for a function to return non-+undefined+ before returning.
*
* @param valueProvider a function that will return a value that is not +undefined+ once the wait should be over
* @param timeout the time to wait between two calls to +valueProvider+
*
* @returns the value that was returned by +valueProvider+
*/
async function waitFor(valueProvider, timeout = 5000) {
while (true) {
const result = await valueProvider();
if (result === null) {
return undefined;
}
else if (result !== undefined) {
return result;
}
await new Promise((cb) => setTimeout(cb, timeout));
}
}
/**
* Waits for a ChangeSet to be available for triggering a StackUpdate.
*
* Will return a changeset that is either ready to be executed or has no changes.
* Will throw in other cases.
*
* @param cfn a CloudFormation client
* @param stackName the name of the Stack that the ChangeSet belongs to
* @param changeSetName the name of the ChangeSet
*
* @returns the CloudFormation description of the ChangeSet
*/
// eslint-disable-next-line max-len
async function waitForChangeSet(cfn, stackName, changeSetName) {
// debug('Waiting for changeset %s on stack %s to finish creating...', changeSetName, stackName)
const ret = await waitFor(async () => {
const description = await describeChangeSet(cfn, stackName, changeSetName);
// The following doesn't use a switch because tsc will not allow fall-through, UNLESS it is allows
// EVERYWHERE that uses this library directly or indirectly, which is undesirable.
if (description.Status === 'CREATE_PENDING' || description.Status === 'CREATE_IN_PROGRESS') {
// debug('Changeset %s on stack %s is still creating', changeSetName, stackName)
return undefined;
}
if (description.Status === 'CREATE_COMPLETE' || changeSetHasNoChanges(description)) {
return description;
}
// eslint-disable-next-line max-len
throw new Error(`Failed to create ChangeSet ${changeSetName} on ${stackName}: ${description.Status || 'NO_STATUS'}, ${description.StatusReason || 'no reason provided'}`);
});
if (!ret) {
throw new Error('Change set took too long to be created; aborting');
}
return ret;
}
exports.waitForChangeSet = waitForChangeSet;
/**
* Return true if the given change set has no changes
*
* This must be determined from the status, not the 'Changes' array on the
* object; the latter can be empty because no resources were changed, but if
* there are changes to Outputs, the change set can still be executed.
*/
function changeSetHasNoChanges(description) {
const noChangeErrorPrefixes = [
// Error message for a regular template
"The submitted information didn't contain changes.",
// Error message when a Transform is involved (see #10650)
'No updates are to be performed.',
];
return (description.Status === 'FAILED' &&
noChangeErrorPrefixes.some((p) => { var _a; return ((_a = description.StatusReason) !== null && _a !== void 0 ? _a : '').startsWith(p); }));
}
exports.changeSetHasNoChanges = changeSetHasNoChanges;
/**
* Waits for a CloudFormation stack to stabilize in a complete/available state
* after a delete operation is issued.
*
* Fails if the stack is in a FAILED state. Will not fail if the stack was
* already deleted.
*
* @param cfn a CloudFormation client
* @param stackName the name of the stack to wait for after a delete
*
* @returns the CloudFormation description of the stabilized stack after the delete attempt
*/
async function waitForStackDelete(cfn, stackName) {
const stack = await stabilizeStack(cfn, stackName);
if (!stack) {
return undefined;
}
const status = stack.stackStatus;
if (status.isFailure) {
throw new Error(`The stack named ${stackName} is in a failed state. You may need to delete it from the AWS console : ${status}`);
}
else if (status.isDeleted) {
return undefined;
}
return stack;
}
exports.waitForStackDelete = waitForStackDelete;
/**
* Waits for a CloudFormation stack to stabilize in a complete/available state
* after an update/create operation is issued.
*
* Fails if the stack is in a FAILED state, ROLLBACK state, or DELETED state.
*
* @param cfn a CloudFormation client
* @param stackName the name of the stack to wait for after an update
*
* @returns the CloudFormation description of the stabilized stack after the update attempt
*/
async function waitForStackDeploy(cfn, stackName) {
const stack = await stabilizeStack(cfn, stackName);
if (!stack) {
return undefined;
}
const status = stack.stackStatus;
if (status.isCreationFailure) {
throw new Error(`The stack named ${stackName} failed creation, it may need to be manually deleted from the AWS console: ${status}`);
}
else if (!status.isDeploySuccess) {
throw new Error(`The stack named ${stackName} failed to deploy: ${status}`);
}
return stack;
}
exports.waitForStackDeploy = waitForStackDeploy;
/**
* Wait for a stack to become stable (no longer _IN_PROGRESS), returning it
*/
async function stabilizeStack(cfn, stackName) {
// debug('Waiting for stack %s to finish creating or updating...', stackName)
return waitFor(async () => {
const stack = await CloudFormationStack.lookup(cfn, stackName);
if (!stack.exists) {
// debug('Stack %s does not exist', stackName)
return null;
}
const status = stack.stackStatus;
if (status.isInProgress) {
// debug(
// 'Stack %s has an ongoing operation in progress and is not stable (%s)',
// stackName,
// status,
// )
return undefined;
}
return stack;
});
}
exports.stabilizeStack = stabilizeStack;
/**
* The set of (formal) parameters that have been declared in a template
*/
class TemplateParameters {
constructor(params) {
this.params = params;
}
static fromTemplate(template) {
return new TemplateParameters(template.Parameters || {});
}
/**
* Calculate stack parameters to pass from the given desired parameter values
*
* Will throw if parameters without a Default value or a Previous value are not
* supplied.
*/
supplyAll(updates) {
return new ParameterValues(this.params, updates);
}
/**
* From the template, the given desired values and the current values, calculate the changes to the stack parameters
*
* Will take into account parameters already set on the template (will emit
* 'UsePreviousValue: true' for those unless the value is changed), and will
* throw if parameters without a Default value or a Previous value are not
* supplied.
*/
updateExisting(updates, previousValues) {
return new ParameterValues(this.params, updates, previousValues);
}
}
exports.TemplateParameters = TemplateParameters;
/**
* The set of parameters we're going to pass to a Stack
*/
class ParameterValues {
constructor(formalParams, updates, previousValues = {}) {
this.formalParams = formalParams;
this.values = {};
this.apiParameters = [];
const missingRequired = new Array();
for (const [key, formalParam] of Object.entries(this.formalParams)) {
// Check updates first, then use the previous value (if available), then use
// the default (if available).
//
// If we don't find a parameter value using any of these methods, then that's an error.
const updatedValue = updates[key];
if (updatedValue !== undefined) {
this.values[key] = updatedValue;
this.apiParameters.push({ ParameterKey: key, ParameterValue: updates[key] });
continue;
}
if (key in previousValues) {
this.values[key] = previousValues[key];
this.apiParameters.push({ ParameterKey: key, UsePreviousValue: true });
continue;
}
if (formalParam.Default !== undefined) {
this.values[key] = formalParam.Default;
continue;
}
// Oh no
missingRequired.push(key);
}
if (missingRequired.length > 0) {
throw new Error(`The following CloudFormation Parameters are missing a value: ${missingRequired.join(', ')}`);
}
// Just append all supplied overrides that aren't really expected (this
// will fail CFN but maybe people made typos that they want to be notified
// of)
const unknownParam = ([key, _]) => this.formalParams[key] === undefined;
const hasValue = ([_, value]) => !!value;
for (const [key, value] of Object.entries(updates).filter(unknownParam).filter(hasValue)) {
this.values[key] = value;
this.apiParameters.push({ ParameterKey: key, ParameterValue: value });
}
}
/**
* Whether this set of parameter updates will change the actual stack values
*/
hasChanges(currentValues) {
// If any of the parameters are SSM parameters, deploying must always happen
// because we can't predict what the values will be.
if (Object.values(this.formalParams).some((p) => p.Type.startsWith('AWS::SSM::Parameter::'))) {
return true;
}
// Otherwise we're dirty if:
// - any of the existing values are removed, or changed
if (Object.entries(currentValues).some(([key, value]) => !(key in this.values) || value !== this.values[key])) {
return true;
}
// - any of the values we're setting are new
if (Object.keys(this.values).some((key) => !(key in currentValues))) {
return true;
}
return false;
}
}
exports.ParameterValues = ParameterValues;
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cloudformation.js","sourceRoot":"","sources":["../../../src/providers/aws/cloudformation.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  CloudFormation,\n  Stack,\n  Tag,\n  DescribeChangeSetOutput,\n  Parameter,\n} from '@aws-sdk/client-cloudformation'\nimport {StackStatus} from './stack-status'\nimport * as yaml from './yaml'\n\nexport type Template = {\n  Parameters?: Record<string, TemplateParameter>\n  [key: string]: any\n}\n\ninterface TemplateParameter {\n  Type: string\n  Default?: any\n  [key: string]: any\n}\n\n/**\n * Stringify to YAML\n */\nexport function toYAML(obj: any): string {\n  return yaml.serialize(obj)\n}\n\n/**\n * Parse either YAML or JSON\n */\nfunction deserializeStructure(str: string): any {\n  try {\n    return yaml.deserialize(str)\n  } catch (e) {\n    return JSON.parse(str)\n  }\n}\n\n/**\n * Represents an (existing) Stack in CloudFormation\n *\n * Bundle and cache some information that we need during deployment (so we don't have to make\n * repeated calls to CloudFormation).\n */\nexport class CloudFormationStack {\n  public static async lookup(cfn: CloudFormation, stackName: string): Promise<CloudFormationStack> {\n    try {\n      const response = await cfn.describeStacks({StackName: stackName})\n      return new CloudFormationStack(cfn, stackName, response.Stacks && response.Stacks[0])\n    } catch (e) {\n      if (e instanceof Error) {\n        if (e.message === `Stack with id ${stackName} does not exist`) {\n          return new CloudFormationStack(cfn, stackName, undefined)\n        }\n      }\n      throw e\n    }\n  }\n\n  /**\n   * Return a copy of the given stack that does not exist\n   *\n   * It's a little silly that it needs arguments to do that, but there we go.\n   */\n  public static doesNotExist(cfn: CloudFormation, stackName: string) {\n    return new CloudFormationStack(cfn, stackName)\n  }\n\n  /**\n   * From static information (for testing)\n   */\n  public static fromStaticInformation(cfn: CloudFormation, stackName: string, stack: Stack) {\n    return new CloudFormationStack(cfn, stackName, stack)\n  }\n\n  private _template: any\n\n  protected constructor(\n    private readonly cfn: CloudFormation,\n    public readonly stackName: string,\n    private readonly stack?: Stack,\n  ) {}\n\n  /**\n   * Retrieve the stack's deployed template\n   *\n   * Cached, so will only be retrieved once. Will return an empty\n   * structure if the stack does not exist.\n   */\n  public async template(): Promise<Template> {\n    if (!this.exists) {\n      return {}\n    }\n\n    if (this._template === undefined) {\n      const response = await this.cfn.getTemplate({\n        StackName: this.stackName,\n        TemplateStage: 'Original',\n      })\n      this._template = (response.TemplateBody && deserializeStructure(response.TemplateBody)) || {}\n    }\n    return this._template\n  }\n\n  /**\n   * Whether the stack exists\n   */\n  public get exists() {\n    return this.stack !== undefined\n  }\n\n  /**\n   * The stack's ID\n   *\n   * Throws if the stack doesn't exist.\n   */\n  public get stackId() {\n    this.assertExists()\n    return this.stack!.StackId!\n  }\n\n  /**\n   * The stack's current outputs\n   *\n   * Empty object if the stack doesn't exist\n   */\n  public get outputs(): Record<string, string> {\n    if (!this.exists) {\n      return {}\n    }\n    const result: {[name: string]: string} = {}\n    ;(this.stack!.Outputs || []).forEach((output) => {\n      result[output.OutputKey!] = output.OutputValue!\n    })\n    return result\n  }\n\n  /**\n   * The stack's status\n   *\n   * Special status NOT_FOUND if the stack does not exist.\n   */\n  public get stackStatus(): StackStatus {\n    if (!this.exists) {\n      return new StackStatus('NOT_FOUND', 'Stack not found during lookup')\n    }\n    return StackStatus.fromStackDescription(this.stack!)\n  }\n\n  /**\n   * The stack's current tags\n   *\n   * Empty list of the stack does not exist\n   */\n  public get tags(): Tag[] {\n    return this.stack?.Tags || []\n  }\n\n  /**\n   * Return the names of all current parameters to the stack\n   *\n   * Empty list if the stack does not exist.\n   */\n  public get parameterNames(): string[] {\n    return Object.keys(this.parameters)\n  }\n\n  /**\n   * Return the names and values of all current parameters to the stack\n   *\n   * Empty object if the stack does not exist.\n   */\n  public get parameters(): Record<string, string> {\n    if (!this.exists) {\n      return {}\n    }\n    const ret: Record<string, string> = {}\n    for (const param of this.stack!.Parameters ?? []) {\n      ret[param.ParameterKey!] = param.ParameterValue!\n    }\n    return ret\n  }\n\n  /**\n   * Return the termination protection of the stack\n   */\n  public get terminationProtection(): boolean | undefined {\n    return this.stack?.EnableTerminationProtection\n  }\n\n  private assertExists() {\n    if (!this.exists) {\n      throw new Error(`No stack named '${this.stackName}'`)\n    }\n  }\n}\n\n/**\n * Describe a changeset in CloudFormation, regardless of its current state.\n *\n * @param cfn       a CloudFormation client\n * @param stackName   the name of the Stack the ChangeSet belongs to\n * @param changeSetName the name of the ChangeSet\n *\n * @returns       CloudFormation information about the ChangeSet\n */\nasync function describeChangeSet(\n  cfn: CloudFormation,\n  stackName: string,\n  changeSetName: string,\n): Promise<DescribeChangeSetOutput> {\n  const response = await cfn.describeChangeSet({StackName: stackName, ChangeSetName: changeSetName})\n  return response\n}\n\n/**\n * Waits for a function to return non-+undefined+ before returning.\n *\n * @param valueProvider a function that will return a value that is not +undefined+ once the wait should be over\n * @param timeout     the time to wait between two calls to +valueProvider+\n *\n * @returns       the value that was returned by +valueProvider+\n */\nasync function waitFor<T>(\n  valueProvider: () => Promise<T | null | undefined>,\n  timeout: number = 5000,\n): Promise<T | undefined> {\n  while (true) {\n    const result = await valueProvider()\n    if (result === null) {\n      return undefined\n    } else if (result !== undefined) {\n      return result\n    }\n    await new Promise((cb) => setTimeout(cb, timeout))\n  }\n}\n\n/**\n * Waits for a ChangeSet to be available for triggering a StackUpdate.\n *\n * Will return a changeset that is either ready to be executed or has no changes.\n * Will throw in other cases.\n *\n * @param cfn       a CloudFormation client\n * @param stackName   the name of the Stack that the ChangeSet belongs to\n * @param changeSetName the name of the ChangeSet\n *\n * @returns       the CloudFormation description of the ChangeSet\n */\n// eslint-disable-next-line max-len\nexport async function waitForChangeSet(\n  cfn: CloudFormation,\n  stackName: string,\n  changeSetName: string,\n): Promise<DescribeChangeSetOutput> {\n  // debug('Waiting for changeset %s on stack %s to finish creating...', changeSetName, stackName)\n  const ret = await waitFor(async () => {\n    const description = await describeChangeSet(cfn, stackName, changeSetName)\n    // The following doesn't use a switch because tsc will not allow fall-through, UNLESS it is allows\n    // EVERYWHERE that uses this library directly or indirectly, which is undesirable.\n    if (description.Status === 'CREATE_PENDING' || description.Status === 'CREATE_IN_PROGRESS') {\n      // debug('Changeset %s on stack %s is still creating', changeSetName, stackName)\n      return undefined\n    }\n\n    if (description.Status === 'CREATE_COMPLETE' || changeSetHasNoChanges(description)) {\n      return description\n    }\n\n    // eslint-disable-next-line max-len\n    throw new Error(\n      `Failed to create ChangeSet ${changeSetName} on ${stackName}: ${\n        description.Status || 'NO_STATUS'\n      }, ${description.StatusReason || 'no reason provided'}`,\n    )\n  })\n\n  if (!ret) {\n    throw new Error('Change set took too long to be created; aborting')\n  }\n\n  return ret\n}\n\n/**\n * Return true if the given change set has no changes\n *\n * This must be determined from the status, not the 'Changes' array on the\n * object; the latter can be empty because no resources were changed, but if\n * there are changes to Outputs, the change set can still be executed.\n */\nexport function changeSetHasNoChanges(description: DescribeChangeSetOutput) {\n  const noChangeErrorPrefixes = [\n    // Error message for a regular template\n    \"The submitted information didn't contain changes.\",\n    // Error message when a Transform is involved (see #10650)\n    'No updates are to be performed.',\n  ]\n\n  return (\n    description.Status === 'FAILED' &&\n    noChangeErrorPrefixes.some((p) => (description.StatusReason ?? '').startsWith(p))\n  )\n}\n\n/**\n * Waits for a CloudFormation stack to stabilize in a complete/available state\n * after a delete operation is issued.\n *\n * Fails if the stack is in a FAILED state. Will not fail if the stack was\n * already deleted.\n *\n * @param cfn        a CloudFormation client\n * @param stackName      the name of the stack to wait for after a delete\n *\n * @returns     the CloudFormation description of the stabilized stack after the delete attempt\n */\nexport async function waitForStackDelete(\n  cfn: CloudFormation,\n  stackName: string,\n): Promise<CloudFormationStack | undefined> {\n  const stack = await stabilizeStack(cfn, stackName)\n  if (!stack) {\n    return undefined\n  }\n\n  const status = stack.stackStatus\n  if (status.isFailure) {\n    throw new Error(\n      `The stack named ${stackName} is in a failed state. You may need to delete it from the AWS console : ${status}`,\n    )\n  } else if (status.isDeleted) {\n    return undefined\n  }\n  return stack\n}\n\n/**\n * Waits for a CloudFormation stack to stabilize in a complete/available state\n * after an update/create operation is issued.\n *\n * Fails if the stack is in a FAILED state, ROLLBACK state, or DELETED state.\n *\n * @param cfn        a CloudFormation client\n * @param stackName      the name of the stack to wait for after an update\n *\n * @returns     the CloudFormation description of the stabilized stack after the update attempt\n */\nexport async function waitForStackDeploy(\n  cfn: CloudFormation,\n  stackName: string,\n): Promise<CloudFormationStack | undefined> {\n  const stack = await stabilizeStack(cfn, stackName)\n  if (!stack) {\n    return undefined\n  }\n\n  const status = stack.stackStatus\n\n  if (status.isCreationFailure) {\n    throw new Error(\n      `The stack named ${stackName} failed creation, it may need to be manually deleted from the AWS console: ${status}`,\n    )\n  } else if (!status.isDeploySuccess) {\n    throw new Error(`The stack named ${stackName} failed to deploy: ${status}`)\n  }\n\n  return stack\n}\n\n/**\n * Wait for a stack to become stable (no longer _IN_PROGRESS), returning it\n */\nexport async function stabilizeStack(cfn: CloudFormation, stackName: string) {\n  // debug('Waiting for stack %s to finish creating or updating...', stackName)\n  return waitFor(async () => {\n    const stack = await CloudFormationStack.lookup(cfn, stackName)\n    if (!stack.exists) {\n      // debug('Stack %s does not exist', stackName)\n      return null\n    }\n    const status = stack.stackStatus\n    if (status.isInProgress) {\n      // debug(\n      //   'Stack %s has an ongoing operation in progress and is not stable (%s)',\n      //   stackName,\n      //   status,\n      // )\n      return undefined\n    }\n\n    return stack\n  })\n}\n\n/**\n * The set of (formal) parameters that have been declared in a template\n */\nexport class TemplateParameters {\n  public static fromTemplate(template: Template) {\n    return new TemplateParameters(template.Parameters || {})\n  }\n\n  constructor(private readonly params: Record<string, TemplateParameter>) {}\n\n  /**\n   * Calculate stack parameters to pass from the given desired parameter values\n   *\n   * Will throw if parameters without a Default value or a Previous value are not\n   * supplied.\n   */\n  public supplyAll(updates: Record<string, string | undefined>): ParameterValues {\n    return new ParameterValues(this.params, updates)\n  }\n\n  /**\n   * From the template, the given desired values and the current values, calculate the changes to the stack parameters\n   *\n   * Will take into account parameters already set on the template (will emit\n   * 'UsePreviousValue: true' for those unless the value is changed), and will\n   * throw if parameters without a Default value or a Previous value are not\n   * supplied.\n   */\n  public updateExisting(\n    updates: Record<string, string | undefined>,\n    previousValues: Record<string, string>,\n  ): ParameterValues {\n    return new ParameterValues(this.params, updates, previousValues)\n  }\n}\n\n/**\n * The set of parameters we're going to pass to a Stack\n */\nexport class ParameterValues {\n  public readonly values: Record<string, string> = {}\n  public readonly apiParameters: Parameter[] = []\n\n  constructor(\n    private readonly formalParams: Record<string, TemplateParameter>,\n    updates: Record<string, string | undefined>,\n    previousValues: Record<string, string> = {},\n  ) {\n    const missingRequired = new Array<string>()\n\n    for (const [key, formalParam] of Object.entries(this.formalParams)) {\n      // Check updates first, then use the previous value (if available), then use\n      // the default (if available).\n      //\n      // If we don't find a parameter value using any of these methods, then that's an error.\n      const updatedValue = updates[key]\n      if (updatedValue !== undefined) {\n        this.values[key] = updatedValue\n        this.apiParameters.push({ParameterKey: key, ParameterValue: updates[key]})\n        continue\n      }\n\n      if (key in previousValues) {\n        this.values[key] = previousValues[key]\n        this.apiParameters.push({ParameterKey: key, UsePreviousValue: true})\n        continue\n      }\n\n      if (formalParam.Default !== undefined) {\n        this.values[key] = formalParam.Default\n        continue\n      }\n\n      // Oh no\n      missingRequired.push(key)\n    }\n\n    if (missingRequired.length > 0) {\n      throw new Error(\n        `The following CloudFormation Parameters are missing a value: ${missingRequired.join(\n          ', ',\n        )}`,\n      )\n    }\n\n    // Just append all supplied overrides that aren't really expected (this\n    // will fail CFN but maybe people made typos that they want to be notified\n    // of)\n    const unknownParam = ([key, _]: [string, any]) => this.formalParams[key] === undefined\n    const hasValue = ([_, value]: [string, any]) => !!value\n    for (const [key, value] of Object.entries(updates).filter(unknownParam).filter(hasValue)) {\n      this.values[key] = value!\n      this.apiParameters.push({ParameterKey: key, ParameterValue: value})\n    }\n  }\n\n  /**\n   * Whether this set of parameter updates will change the actual stack values\n   */\n  public hasChanges(currentValues: Record<string, string>): boolean {\n    // If any of the parameters are SSM parameters, deploying must always happen\n    // because we can't predict what the values will be.\n    if (Object.values(this.formalParams).some((p) => p.Type.startsWith('AWS::SSM::Parameter::'))) {\n      return true\n    }\n\n    // Otherwise we're dirty if:\n    // - any of the existing values are removed, or changed\n    if (\n      Object.entries(currentValues).some(\n        ([key, value]) => !(key in this.values) || value !== this.values[key],\n      )\n    ) {\n      return true\n    }\n\n    // - any of the values we're setting are new\n    if (Object.keys(this.values).some((key) => !(key in currentValues))) {\n      return true\n    }\n\n    return false\n  }\n}\n"]}