@kensio/yulin 1.21.3 → 1.21.5

package/dist/service/cloudformation/changeset/sim-cfn-change-set-changes.d.ts

@@ -0,0 +1,42 @@
+import type { BackgroundScheduler } from "../../../util/background/background.js";
+import type { SimAwsAccountRegionScope } from "../../aws/sim-aws-account-region-scope.js";
+import type { SimCfnResource } from "../resource/sim-cfn-resource.js";
+import type { SimCfnStack } from "../stack/sim-cfn-stack.js";
+import type { SimCfnTemplate } from "../template/sim-cfn-template.js";
+import type { SimCfnChangeSetType, SimCfnResourceChange } from "./sim-cfn-change-set.type.js";
+interface SimCfnChangeSetPlanProperties {
+    readonly accountRegionScope: SimAwsAccountRegionScope;
+    readonly background: BackgroundScheduler;
+    readonly stack: SimCfnStack;
+    readonly type: SimCfnChangeSetType;
+    readonly template: SimCfnTemplate;
+}
+/**
+ * What executing a change set would do to the Stack it is held against.
+ *
+ * A `CREATE` change set is compared against nothing, because the Stack it
+ * brought into being holds no created Resource yet.
+ */
+export declare function simCfnChangeSetPlan(properties: SimCfnChangeSetPlanProperties): readonly SimCfnResourceChange[];
+interface SimCfnChangeSetChangesProperties {
+    /** The Resources the Stack holds now. Empty for a Stack in review. */
+    readonly current: ReadonlyMap<string, SimCfnResource>;
+    /** The Resources the change set's template describes. */
+    readonly updated: ReadonlyMap<string, SimCfnResource>;
+}
+/**
+ * What executing a change set would do to a Stack's Resources.
+ *
+ * The same comparison an update makes, reported rather than applied. A
+ * Resource only the new template has is an `Add`, one only the Stack has is a
+ * `Remove`, and one both have whose resolved template entry changed is a
+ * `Modify`. A Resource that would be replaced because it names a replaced one
+ * is a `Modify` too, which is how CloudFormation reports a dependent it has to
+ * hand a new physical name to.
+ *
+ * The order follows the templates. The new template's Resources come first, in
+ * the order it declares them, and the dropped ones after in the order the Stack
+ * holds them.
+ */
+export declare function simCfnChangeSetChanges(properties: SimCfnChangeSetChangesProperties): readonly SimCfnResourceChange[];
+export {};

package/dist/service/cloudformation/changeset/sim-cfn-change-set-changes.js

@@ -0,0 +1,69 @@
+import { makeSimCfnStackResourceMap } from "../stack/resource-map/sim-cfn-stack-resource-map.js";
+import { simCfnStackReplacedLogicalIds } from "../stack/update/sim-cfn-stack-replaced-resources.js";
+/**
+ * What executing a change set would do to the Stack it is held against.
+ *
+ * A `CREATE` change set is compared against nothing, because the Stack it
+ * brought into being holds no created Resource yet.
+ */
+export function simCfnChangeSetPlan(properties) {
+    const { accountRegionScope, background, stack, type, template } = properties;
+    return simCfnChangeSetChanges({
+        current: type === "CREATE" ? new Map() : stack.resourceMap,
+        updated: makeSimCfnStackResourceMap({
+            accountRegionScope,
+            background,
+            template,
+        }),
+    });
+}
+/**
+ * What executing a change set would do to a Stack's Resources.
+ *
+ * The same comparison an update makes, reported rather than applied. A
+ * Resource only the new template has is an `Add`, one only the Stack has is a
+ * `Remove`, and one both have whose resolved template entry changed is a
+ * `Modify`. A Resource that would be replaced because it names a replaced one
+ * is a `Modify` too, which is how CloudFormation reports a dependent it has to
+ * hand a new physical name to.
+ *
+ * The order follows the templates. The new template's Resources come first, in
+ * the order it declares them, and the dropped ones after in the order the Stack
+ * holds them.
+ */
+export function simCfnChangeSetChanges(properties) {
+    const { current, updated } = properties;
+    const replaced = simCfnStackReplacedLogicalIds({ current, updated });
+    const changed = updated
+        .values()
+        .filter((resource) => !unchanged(resource, current, replaced))
+        .map((resource) => ({
+        action: current.has(resource.logicalId)
+            ? "Modify"
+            : "Add",
+        logicalResourceId: resource.logicalId,
+        resourceType: resource.type,
+        replacement: current.has(resource.logicalId)
+            ? "True"
+            : undefined,
+    }))
+        .toArray();
+    const removed = current
+        .values()
+        .filter((resource) => !updated.has(resource.logicalId))
+        .map((resource) => ({
+        action: "Remove",
+        logicalResourceId: resource.logicalId,
+        resourceType: resource.type,
+        replacement: undefined,
+    }))
+        .toArray();
+    return [...changed, ...removed];
+}
+/**
+ * Whether the Stack already holds this Resource as the new template describes
+ * it, which is a Resource the change set leaves out.
+ */
+function unchanged(resource, current, replaced) {
+    return current.has(resource.logicalId) && !replaced.has(resource.logicalId);
+}

package/dist/service/cloudformation/changeset/sim-cfn-change-set-commands.d.ts

@@ -0,0 +1,62 @@
+import type { BackgroundCompleter, BackgroundScheduler } from "../../../util/background/background.js";
+import type { SimAws } from "../../aws/sim-aws.js";
+import type { SimAwsAccountRegionScope } from "../../aws/sim-aws-account-region-scope.js";
+import type { SimAwsCaller } from "../../aws/caller/sim-aws-caller.js";
+import type { SimCfnStack } from "../stack/sim-cfn-stack.js";
+import type { SimCloudFormationStackName } from "../stack/sim-cfn-stack.type.js";
+import type { SimCfnExports } from "../export/sim-cfn-exports.js";
+import type { SimCloudFormationAuthorization } from "../authorize/sim-cloudformation-authorization.js";
+import type { SimCreateChangeSetCommand, SimCreateChangeSetCommandOutput } from "../command/create-change-set/create-change-set.command.js";
+import type { SimDescribeChangeSetCommand, SimDescribeChangeSetCommandOutput } from "../command/describe-change-set/describe-change-set.command.js";
+import type { SimExecuteChangeSetCommand, SimExecuteChangeSetCommandOutput } from "../command/execute-change-set/execute-change-set.command.js";
+import type { SimDeleteChangeSetCommand, SimDeleteChangeSetCommandOutput } from "../command/delete-change-set/delete-change-set.command.js";
+import type { SimListChangeSetsCommand, SimListChangeSetsCommandOutput } from "../command/list-change-sets/list-change-sets.command.js";
+interface SimCfnChangeSetCommandsProperties {
+    readonly simAws: SimAws;
+    readonly accountRegionScope: SimAwsAccountRegionScope;
+    readonly stacks: Map<SimCloudFormationStackName, SimCfnStack>;
+    readonly background: BackgroundScheduler & BackgroundCompleter;
+    readonly authorization: SimCloudFormationAuthorization;
+    readonly exports?: SimCfnExports | undefined;
+}
+/**
+ * The change set half of simulated CloudFormation's SDK surface.
+ *
+ * The five change set commands share one registry of held change sets and the
+ * same Stack map every other command reads, so they are assembled once here
+ * rather than in SimCloudFormation alongside the Stack commands.
+ *
+ * Authorization happens here rather than in SimCloudFormation, because three of
+ * the five commands can name a change set by its ARN alone. The Stack such a
+ * request operates on is the one the change set belongs to, and only this
+ * registry knows which that is.
+ */
+export declare class SimCfnChangeSetCommands {
+    private readonly properties;
+    private readonly changeSets;
+    constructor(properties: SimCfnChangeSetCommandsProperties);
+    /** Work out what a template would change about a Stack, and hold it. */
+    create(command: SimCreateChangeSetCommand, caller?: SimAwsCaller): Promise<SimCreateChangeSetCommandOutput>;
+    /** Report what a held change set would do to its Stack. */
+    describe(command: SimDescribeChangeSetCommand, caller?: SimAwsCaller): Promise<SimDescribeChangeSetCommandOutput>;
+    /** Apply what a change set describes to its Stack. */
+    execute(command: SimExecuteChangeSetCommand, caller?: SimAwsCaller): Promise<SimExecuteChangeSetCommandOutput>;
+    /** Take a change set away without executing it. */
+    delete(command: SimDeleteChangeSetCommand, caller?: SimAwsCaller): Promise<SimDeleteChangeSetCommandOutput>;
+    /** List the change sets held against one Stack. */
+    list(command: SimListChangeSetsCommand, caller?: SimAwsCaller): Promise<SimListChangeSetsCommandOutput>;
+    /**
+     * The Stack a request naming one change set operates on.
+     *
+     * A request carrying the change set ARN alone leaves out the Stack name, and
+     * the change set it names knows which Stack it belongs to. Authorizing on
+     * what the request said would ask about every Stack in the scope, so a
+     * caller allowed one Stack would be refused a change set against it.
+     *
+     * A change set the registry does not hold falls back to what the request
+     * said. The handler refuses it, and refusing an unauthorized caller first is
+     * what keeps that refusal from saying which change sets exist.
+     */
+    private stackNameFor;
+}
+export {};

package/dist/service/cloudformation/changeset/sim-cfn-change-set-commands.js

@@ -0,0 +1,89 @@
+import { CreateChangeSetCommandHandler } from "../command/create-change-set/create-change-set.handler.js";
+import { DescribeChangeSetCommandHandler } from "../command/describe-change-set/describe-change-set.handler.js";
+import { ExecuteChangeSetCommandHandler } from "../command/execute-change-set/execute-change-set.handler.js";
+import { DeleteChangeSetCommandHandler } from "../command/delete-change-set/delete-change-set.handler.js";
+import { ListChangeSetsCommandHandler } from "../command/list-change-sets/list-change-sets.handler.js";
+import { SimCfnChangeSets } from "./sim-cfn-change-sets.js";
+/**
+ * The change set half of simulated CloudFormation's SDK surface.
+ *
+ * The five change set commands share one registry of held change sets and the
+ * same Stack map every other command reads, so they are assembled once here
+ * rather than in SimCloudFormation alongside the Stack commands.
+ *
+ * Authorization happens here rather than in SimCloudFormation, because three of
+ * the five commands can name a change set by its ARN alone. The Stack such a
+ * request operates on is the one the change set belongs to, and only this
+ * registry knows which that is.
+ */
+export class SimCfnChangeSetCommands {
+    properties;
+    changeSets = new SimCfnChangeSets();
+    constructor(properties) {
+        this.properties = properties;
+    }
+    /** Work out what a template would change about a Stack, and hold it. */
+    async create(command, caller) {
+        this.properties.authorization.createChangeSet(command.input.StackName, caller);
+        return await new CreateChangeSetCommandHandler({
+            ...this.properties,
+            changeSets: this.changeSets,
+            caller,
+        }).handle(command);
+    }
+    /** Report what a held change set would do to its Stack. */
+    async describe(command, caller) {
+        this.properties.authorization.describeChangeSet(this.stackNameFor(command.input), caller);
+        return await new DescribeChangeSetCommandHandler({
+            changeSets: this.changeSets,
+            background: this.properties.background,
+        }).handle(command);
+    }
+    /** Apply what a change set describes to its Stack. */
+    async execute(command, caller) {
+        this.properties.authorization.executeChangeSet(this.stackNameFor(command.input), caller);
+        return await new ExecuteChangeSetCommandHandler({
+            stacks: this.properties.stacks,
+            changeSets: this.changeSets,
+            background: this.properties.background,
+            caller,
+        }).handle(command);
+    }
+    /** Take a change set away without executing it. */
+    async delete(command, caller) {
+        this.properties.authorization.deleteChangeSet(this.stackNameFor(command.input), caller);
+        return await new DeleteChangeSetCommandHandler({
+            changeSets: this.changeSets,
+            background: this.properties.background,
+        }).handle(command);
+    }
+    /** List the change sets held against one Stack. */
+    async list(command, caller) {
+        this.properties.authorization.listChangeSets(command.input.StackName, caller);
+        return await new ListChangeSetsCommandHandler({
+            changeSets: this.changeSets,
+            background: this.properties.background,
+        }).handle(command);
+    }
+    /**
+     * The Stack a request naming one change set operates on.
+     *
+     * A request carrying the change set ARN alone leaves out the Stack name, and
+     * the change set it names knows which Stack it belongs to. Authorizing on
+     * what the request said would ask about every Stack in the scope, so a
+     * caller allowed one Stack would be refused a change set against it.
+     *
+     * A change set the registry does not hold falls back to what the request
+     * said. The handler refuses it, and refusing an unauthorized caller first is
+     * what keeps that refusal from saying which change sets exist.
+     */
+    stackNameFor(input) {
+        if (input.ChangeSetName === undefined) {
+            return input.StackName;
+        }
+        return (this.changeSets.find({
+            changeSetName: input.ChangeSetName,
+            stackName: input.StackName,
+        })?.stackName ?? input.StackName);
+    }
+}

package/dist/service/cloudformation/changeset/sim-cfn-change-set-execution.d.ts

@@ -0,0 +1,31 @@
+import type { BackgroundScheduler } from "../../../util/background/background.js";
+import type { SimAwsCaller } from "../../aws/caller/sim-aws-caller.js";
+import type { SimCfnStack } from "../stack/sim-cfn-stack.js";
+import type { SimCfnChangeSet } from "./sim-cfn-change-set.js";
+import { type SimCfnChangeSets } from "./sim-cfn-change-sets.js";
+interface SimCfnChangeSetExecutionProperties {
+    readonly changeSet: SimCfnChangeSet;
+    readonly stack: SimCfnStack;
+    readonly changeSets: SimCfnChangeSets;
+    readonly background: BackgroundScheduler;
+    readonly caller?: SimAwsCaller | undefined;
+}
+/**
+ * Start the Stack operation a change set describes.
+ *
+ * A `CREATE` change set deploys the Stack it brought into being, and an
+ * `UPDATE` change set applies its template to the Stack it was worked out
+ * against. Either way the work is scheduled in the background, so this returns
+ * once the operation has started.
+ *
+ * A Stack that has moved on since the change set was worked out leaves the
+ * change set obsolete, which is what CloudFormation calls a change set whose
+ * Stack was already updated. Executing it would apply a difference nobody has
+ * seen, because what it reports was worked out against the template the Stack
+ * held then.
+ *
+ * Every other executable change set against the Stack becomes obsolete for the
+ * same reason once this one has been applied.
+ */
+export declare function runSimCfnChangeSet(properties: SimCfnChangeSetExecutionProperties): Promise<void>;
+export {};

package/dist/service/cloudformation/changeset/sim-cfn-change-set-execution.js

@@ -0,0 +1,59 @@
+import { simCfnStackTemplateChanged } from "../stack/update/sim-cfn-stack-template-changes.js";
+import { simCfnChangeSetNotExecutable, } from "./sim-cfn-change-sets.js";
+/**
+ * Start the Stack operation a change set describes.
+ *
+ * A `CREATE` change set deploys the Stack it brought into being, and an
+ * `UPDATE` change set applies its template to the Stack it was worked out
+ * against. Either way the work is scheduled in the background, so this returns
+ * once the operation has started.
+ *
+ * A Stack that has moved on since the change set was worked out leaves the
+ * change set obsolete, which is what CloudFormation calls a change set whose
+ * Stack was already updated. Executing it would apply a difference nobody has
+ * seen, because what it reports was worked out against the template the Stack
+ * held then.
+ *
+ * Every other executable change set against the Stack becomes obsolete for the
+ * same reason once this one has been applied.
+ */
+export async function runSimCfnChangeSet(properties) {
+    const { changeSet, stack, changeSets, background, caller } = properties;
+    if (simCfnStackTemplateChanged(changeSet.plannedFrom, stack.currentTemplate)) {
+        changeSet.executionStatus = "OBSOLETE";
+        throw simCfnChangeSetNotExecutable(changeSet);
+    }
+    changeSet.executionStatus = "EXECUTE_IN_PROGRESS";
+    try {
+        await (changeSet.type === "CREATE"
+            ? stack.deploy()
+            : stack.update(changeSet.template, { caller }));
+    }
+    catch (error) {
+        changeSet.executionStatus = "EXECUTE_FAILED";
+        throw error;
+    }
+    changeSets.markOthersObsolete(changeSet);
+    settleExecution(changeSet, stack, background);
+}
+/**
+ * Record how the Stack operation went, once it has finished in the background.
+ *
+ * The failure itself belongs to the Stack, which holds it as a failed status
+ * and rethrows it to whoever waits for the operation. This only reads which way
+ * it went, so a change set describes its own execution as well as the Stack
+ * describes the deployment or update behind it.
+ */
+function settleExecution(changeSet, stack, background) {
+    background.schedule(async () => {
+        try {
+            await (changeSet.type === "CREATE"
+                ? stack.waitForDeployComplete()
+                : stack.waitForUpdateComplete());
+            changeSet.executionStatus = "EXECUTE_COMPLETE";
+        }
+        catch {
+            changeSet.executionStatus = "EXECUTE_FAILED";
+        }
+    });
+}

package/dist/service/cloudformation/changeset/sim-cfn-change-set-failure.d.ts

@@ -0,0 +1,21 @@
+import type { SimCfnStack } from "../stack/sim-cfn-stack.js";
+import type { SimCfnTemplate } from "../template/sim-cfn-template.js";
+import type { SimCfnChangeSetType } from "./sim-cfn-change-set.type.js";
+interface SimCfnChangeSetFailureProperties {
+    readonly stack: SimCfnStack;
+    readonly type: SimCfnChangeSetType;
+    readonly template: SimCfnTemplate;
+    readonly changeCount: number;
+}
+/**
+ * Why a change set failed, for one that would change nothing.
+ *
+ * Everything else in the template counts as well as the Resources, the same way
+ * it does for an update, because a change set that only moves an Output still
+ * has something to execute.
+ *
+ * A `CREATE` change set never fails this way. The Stack it was made for holds
+ * no Resource, so there is always something for it to do.
+ */
+export declare function simCfnChangeSetFailure(properties: SimCfnChangeSetFailureProperties): string | undefined;
+export {};

package/dist/service/cloudformation/changeset/sim-cfn-change-set-failure.js

@@ -0,0 +1,19 @@
+import { simCfnStackTemplateChanged } from "../stack/update/sim-cfn-stack-template-changes.js";
+import { simCfnChangeSetNoChangesMessage } from "./sim-cfn-change-set-type.js";
+/**
+ * Why a change set failed, for one that would change nothing.
+ *
+ * Everything else in the template counts as well as the Resources, the same way
+ * it does for an update, because a change set that only moves an Output still
+ * has something to execute.
+ *
+ * A `CREATE` change set never fails this way. The Stack it was made for holds
+ * no Resource, so there is always something for it to do.
+ */
+export function simCfnChangeSetFailure(properties) {
+    const { stack, type, template, changeCount } = properties;
+    const noChanges = type === "UPDATE" &&
+        changeCount === 0 &&
+        !simCfnStackTemplateChanged(stack.currentTemplate, template);
+    return noChanges ? simCfnChangeSetNoChangesMessage : undefined;
+}

package/dist/service/cloudformation/changeset/sim-cfn-change-set-input.d.ts

@@ -0,0 +1,17 @@
+import type { SimCloudFormationStackName } from "../stack/sim-cfn-stack.type.js";
+import type { SimCreateChangeSetCommandInput } from "../command/create-change-set/create-change-set.command.js";
+import type { SimCfnChangeSetName, SimCfnChangeSetType } from "./sim-cfn-change-set.type.js";
+/**
+ * What a CreateChangeSet input says, once it has been read.
+ */
+export interface SimCfnChangeSetRequest {
+    readonly stackName: SimCloudFormationStackName;
+    readonly changeSetName: SimCfnChangeSetName;
+    readonly type: SimCfnChangeSetType;
+    readonly templateBody: string;
+}
+/**
+ * Read a CreateChangeSet input, refusing one that leaves out what a change set
+ * cannot be built without.
+ */
+export declare function simCfnChangeSetRequest(input: SimCreateChangeSetCommandInput): SimCfnChangeSetRequest;

package/dist/service/cloudformation/changeset/sim-cfn-change-set-input.js

@@ -0,0 +1,18 @@
+import { assertDefined } from "../../../util/type-guard/defined.js";
+import { simCfnChangeSetType } from "./sim-cfn-change-set-type.js";
+/**
+ * Read a CreateChangeSet input, refusing one that leaves out what a change set
+ * cannot be built without.
+ */
+export function simCfnChangeSetRequest(input) {
+    const { StackName, ChangeSetName, TemplateBody } = input;
+    assertDefined(StackName, "CreateChangeSetCommand.input.StackName");
+    assertDefined(ChangeSetName, "CreateChangeSetCommand.input.ChangeSetName");
+    assertDefined(TemplateBody, "CreateChangeSetCommand.input.TemplateBody");
+    return {
+        stackName: StackName,
+        changeSetName: ChangeSetName,
+        type: simCfnChangeSetType(input.ChangeSetType),
+        templateBody: TemplateBody,
+    };
+}

package/dist/service/cloudformation/changeset/sim-cfn-change-set-stack-id.d.ts

@@ -0,0 +1,18 @@
+import type { SimAwsAccountRegionScope } from "../../aws/sim-aws-account-region-scope.js";
+import type { SimCfnStack } from "../stack/sim-cfn-stack.js";
+import type { SimCloudFormationStackName } from "../stack/sim-cfn-stack.type.js";
+import { type SimCfnStackId } from "../stack/sim-cfn-stack-id.js";
+interface SimCfnChangeSetStackIdProperties {
+    readonly accountRegionScope: SimAwsAccountRegionScope;
+    readonly stacks: ReadonlyMap<SimCloudFormationStackName, SimCfnStack>;
+    readonly stackName: SimCloudFormationStackName;
+}
+/**
+ * The Stack ID a change set's template resolves `AWS::StackId` to.
+ *
+ * An `UPDATE` change set is held against a Stack that already has one. A
+ * `CREATE` change set brings the Stack into being, and this is the ID that
+ * Stack keeps for the rest of its life.
+ */
+export declare function simCfnChangeSetStackId(properties: SimCfnChangeSetStackIdProperties): SimCfnStackId;
+export {};

package/dist/service/cloudformation/changeset/sim-cfn-change-set-stack-id.js

@@ -0,0 +1,13 @@
+import { makeSimCfnStackId, } from "../stack/sim-cfn-stack-id.js";
+/**
+ * The Stack ID a change set's template resolves `AWS::StackId` to.
+ *
+ * An `UPDATE` change set is held against a Stack that already has one. A
+ * `CREATE` change set brings the Stack into being, and this is the ID that
+ * Stack keeps for the rest of its life.
+ */
+export function simCfnChangeSetStackId(properties) {
+    const { accountRegionScope, stacks, stackName } = properties;
+    return (stacks.get(stackName)?.stackId ??
+        makeSimCfnStackId({ accountRegionScope, stackName }));
+}

package/dist/service/cloudformation/changeset/sim-cfn-change-set-stack.d.ts

@@ -0,0 +1,45 @@
+import type { BackgroundCompleter, BackgroundScheduler } from "../../../util/background/background.js";
+import type { SimAws } from "../../aws/sim-aws.js";
+import type { SimAwsAccountRegionScope } from "../../aws/sim-aws-account-region-scope.js";
+import type { SimAwsCaller } from "../../aws/caller/sim-aws-caller.js";
+import { SimCfnStack } from "../stack/sim-cfn-stack.js";
+import type { SimCfnStackId } from "../stack/sim-cfn-stack-id.js";
+import type { SimCloudFormationStackName } from "../stack/sim-cfn-stack.type.js";
+import type { SimCfnExports } from "../export/sim-cfn-exports.js";
+import type { SimCfnTemplate } from "../template/sim-cfn-template.js";
+import type { SimCfnChangeSetType } from "./sim-cfn-change-set.type.js";
+interface SimCfnChangeSetStackProperties {
+    readonly simAws: SimAws;
+    readonly accountRegionScope: SimAwsAccountRegionScope;
+    readonly stacks: Map<SimCloudFormationStackName, SimCfnStack>;
+    readonly background: BackgroundScheduler & BackgroundCompleter;
+    readonly stackName: SimCloudFormationStackName;
+    readonly stackId: SimCfnStackId;
+    readonly type: SimCfnChangeSetType;
+    readonly template: SimCfnTemplate;
+    readonly caller?: SimAwsCaller | undefined;
+    readonly exports?: SimCfnExports | undefined;
+}
+/**
+ * The Stack a change set is held against.
+ *
+ * A `CREATE` change set brings the Stack into being in review, which is the
+ * status a Stack holds before anything has deployed it. Its Resources are
+ * worked out from the template and none of them is created, so executing the
+ * change set is what deploys them.
+ *
+ * An `UPDATE` change set needs a Stack that is already there, and leaves it
+ * exactly as it is.
+ */
+export declare function simCfnChangeSetStack(properties: SimCfnChangeSetStackProperties): SimCfnStack;
+/**
+ * The Stack a change set was created against, for executing it.
+ *
+ * A Stack that has gone since the change set was created leaves the change set
+ * naming nothing, which CloudFormation refuses the way it refuses any command
+ * naming a Stack it cannot find.
+ */
+export declare function simCfnChangeSetDeployedStack(stacks: ReadonlyMap<SimCloudFormationStackName, SimCfnStack>, changeSet: {
+    readonly stackName: SimCloudFormationStackName;
+}): SimCfnStack;
+export {};

package/dist/service/cloudformation/changeset/sim-cfn-change-set-stack.js

@@ -0,0 +1,52 @@
+import { SimCfnStack } from "../stack/sim-cfn-stack.js";
+import { SimCloudFormationAlreadyExistsException, SimCloudFormationValidationError, } from "../error/sim-cloudformation.error.js";
+/**
+ * The Stack a change set is held against.
+ *
+ * A `CREATE` change set brings the Stack into being in review, which is the
+ * status a Stack holds before anything has deployed it. Its Resources are
+ * worked out from the template and none of them is created, so executing the
+ * change set is what deploys them.
+ *
+ * An `UPDATE` change set needs a Stack that is already there, and leaves it
+ * exactly as it is.
+ */
+export function simCfnChangeSetStack(properties) {
+    const { stacks, stackName, type } = properties;
+    const deployed = stacks.get(stackName);
+    if (type === "UPDATE") {
+        if (deployed === undefined) {
+            throw new SimCloudFormationValidationError(`Stack [${stackName}] does not exist`);
+        }
+        return deployed;
+    }
+    if (deployed !== undefined) {
+        throw new SimCloudFormationAlreadyExistsException(`Stack [${stackName}] already exists`);
+    }
+    const stack = new SimCfnStack({
+        simAws: properties.simAws,
+        accountRegionScope: properties.accountRegionScope,
+        background: properties.background,
+        stackName,
+        stackId: properties.stackId,
+        template: properties.template,
+        caller: properties.caller,
+        exports: properties.exports,
+    });
+    stacks.set(stack.stackName, stack);
+    return stack;
+}
+/**
+ * The Stack a change set was created against, for executing it.
+ *
+ * A Stack that has gone since the change set was created leaves the change set
+ * naming nothing, which CloudFormation refuses the way it refuses any command
+ * naming a Stack it cannot find.
+ */
+export function simCfnChangeSetDeployedStack(stacks, changeSet) {
+    const stack = stacks.get(changeSet.stackName);
+    if (stack === undefined) {
+        throw new SimCloudFormationValidationError(`Stack [${changeSet.stackName}] does not exist`);
+    }
+    return stack;
+}

package/dist/service/cloudformation/changeset/sim-cfn-change-set-type.d.ts

@@ -0,0 +1,12 @@
+import type { SimCfnChangeSetType } from "./sim-cfn-change-set.type.js";
+/**
+ * What CloudFormation answers a change set that would change nothing.
+ */
+export declare const simCfnChangeSetNoChangesMessage: string;
+/**
+ * Read the ChangeSetType a CreateChangeSet input asks for.
+ *
+ * CloudFormation defaults to `UPDATE`. `IMPORT` is outside the simulation,
+ * because nothing here can adopt a Resource it did not create.
+ */
+export declare function simCfnChangeSetType(changeSetType: string | undefined): SimCfnChangeSetType;

package/dist/service/cloudformation/changeset/sim-cfn-change-set-type.js

@@ -0,0 +1,21 @@
+import { SimCloudFormationValidationError } from "../error/sim-cloudformation.error.js";
+/**
+ * What CloudFormation answers a change set that would change nothing.
+ */
+export const simCfnChangeSetNoChangesMessage = "The submitted information didn't contain changes. " +
+    "Submit different information to create a change set.";
+/**
+ * Read the ChangeSetType a CreateChangeSet input asks for.
+ *
+ * CloudFormation defaults to `UPDATE`. `IMPORT` is outside the simulation,
+ * because nothing here can adopt a Resource it did not create.
+ */
+export function simCfnChangeSetType(changeSetType) {
+    if (changeSetType === undefined || changeSetType === "UPDATE") {
+        return "UPDATE";
+    }
+    if (changeSetType === "CREATE") {
+        return "CREATE";
+    }
+    throw new SimCloudFormationValidationError(`Sim CloudFormation ChangeSetType ${changeSetType} is not supported`);
+}