@kensio/yulin 1.21.2 → 1.21.4

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`);
+}

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

@@ -0,0 +1,54 @@
+import type { SimAwsAccountRegionScope } from "../../aws/sim-aws-account-region-scope.js";
+import type { SimCfnTemplate } from "../template/sim-cfn-template.js";
+import type { SimCloudFormationStackName } from "../stack/sim-cfn-stack.type.js";
+import type { SimCfnStackId } from "../stack/sim-cfn-stack-id.js";
+import type { SimCfnChangeSetExecutionStatus, SimCfnChangeSetName, SimCfnChangeSetStatus, SimCfnChangeSetType, SimCfnResourceChange } from "./sim-cfn-change-set.type.js";
+interface SimCfnChangeSetProperties {
+    readonly accountRegionScope: SimAwsAccountRegionScope;
+    readonly changeSetName: SimCfnChangeSetName;
+    readonly stackName: SimCloudFormationStackName;
+    readonly stackId: SimCfnStackId;
+    readonly type: SimCfnChangeSetType;
+    readonly template: SimCfnTemplate;
+    readonly changes: readonly SimCfnResourceChange[];
+    /**
+     * The template the Stack was on when the changes were worked out. A Stack
+     * that has moved on from it leaves the change set obsolete.
+     */
+    readonly plannedFrom: SimCfnTemplate;
+    readonly description?: string | undefined;
+    /** Why the change set failed, for one the simulator refused to build. */
+    readonly failureReason?: string | undefined;
+}
+/**
+ * One change set held against a simulated CloudFormation Stack.
+ *
+ * It holds the template it was created from and the Resource changes executing
+ * it would make. The changes are worked out when the change set is created and
+ * kept as they were, which is the point of a change set: what it reports is
+ * what was true of the Stack at the moment it was asked for.
+ *
+ * Executing it belongs to SimCloudFormation. This class only records how far
+ * that execution got.
+ */
+export declare class SimCfnChangeSet {
+    readonly changeSetId: string;
+    readonly changeSetName: SimCfnChangeSetName;
+    readonly stackName: SimCloudFormationStackName;
+    readonly stackId: SimCfnStackId;
+    readonly type: SimCfnChangeSetType;
+    readonly template: SimCfnTemplate;
+    readonly changes: readonly SimCfnResourceChange[];
+    readonly plannedFrom: SimCfnTemplate;
+    readonly description: string | undefined;
+    /** How far the change set itself got. */
+    status: SimCfnChangeSetStatus;
+    /** Why the change set is in the status it is in, where there is a reason. */
+    readonly statusReason: string | undefined;
+    /** Whether the change set can be executed, and how execution went. */
+    executionStatus: SimCfnChangeSetExecutionStatus;
+    constructor(properties: SimCfnChangeSetProperties);
+    /** Whether ExecuteChangeSet will take this change set. */
+    get executable(): boolean;
+}
+export {};

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

@@ -0,0 +1,49 @@
+import { simCfnChangeSetArn } from "./sim-cfn-change-set-arn.js";
+/**
+ * One change set held against a simulated CloudFormation Stack.
+ *
+ * It holds the template it was created from and the Resource changes executing
+ * it would make. The changes are worked out when the change set is created and
+ * kept as they were, which is the point of a change set: what it reports is
+ * what was true of the Stack at the moment it was asked for.
+ *
+ * Executing it belongs to SimCloudFormation. This class only records how far
+ * that execution got.
+ */
+export class SimCfnChangeSet {
+    changeSetId;
+    changeSetName;
+    stackName;
+    stackId;
+    type;
+    template;
+    changes;
+    plannedFrom;
+    description;
+    /** How far the change set itself got. */
+    status;
+    /** Why the change set is in the status it is in, where there is a reason. */
+    statusReason;
+    /** Whether the change set can be executed, and how execution went. */
+    executionStatus;
+    constructor(properties) {
+        const { changeSetName, failureReason } = properties;
+        const built = failureReason === undefined;
+        this.changeSetName = changeSetName;
+        this.stackName = properties.stackName;
+        this.stackId = properties.stackId;
+        this.type = properties.type;
+        this.template = properties.template;
+        this.changes = properties.changes;
+        this.plannedFrom = properties.plannedFrom;
+        this.description = properties.description;
+        this.changeSetId = simCfnChangeSetArn(properties.accountRegionScope, changeSetName);
+        this.status = built ? "CREATE_COMPLETE" : "FAILED";
+        this.statusReason = failureReason;
+        this.executionStatus = built ? "AVAILABLE" : "UNAVAILABLE";
+    }
+    /** Whether ExecuteChangeSet will take this change set. */
+    get executable() {
+        return this.executionStatus === "AVAILABLE";
+    }
+}

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

@@ -0,0 +1,35 @@
+import type { Brand } from "../../../util/brand.type.js";
+export type SimCfnChangeSetName = Brand<string, "SimCfnChangeSetName">;
+/**
+ * How far the change set itself has got.
+ *
+ * A change set the simulator refused to build lands in `FAILED` carrying the
+ * reason, which is what CloudFormation does with a change set describing no
+ * change at all.
+ */
+export type SimCfnChangeSetStatus = "CREATE_IN_PROGRESS" | "CREATE_COMPLETE" | "DELETE_COMPLETE" | "FAILED";
+/**
+ * Whether the change set can be executed, and how the execution went.
+ *
+ * `OBSOLETE` is what a change set becomes once another one against the same
+ * Stack has been executed, because the plan it holds was worked out against a
+ * Stack that has moved on.
+ */
+export type SimCfnChangeSetExecutionStatus = "UNAVAILABLE" | "AVAILABLE" | "EXECUTE_IN_PROGRESS" | "EXECUTE_COMPLETE" | "EXECUTE_FAILED" | "OBSOLETE";
+/**
+ * Whether executing the change set creates the Stack or updates it.
+ */
+export type SimCfnChangeSetType = "CREATE" | "UPDATE";
+export type SimCfnResourceChangeAction = "Add" | "Modify" | "Remove";
+/**
+ * One Resource a change set would create, replace or delete.
+ *
+ * `replacement` is `True` on every `Modify`. Simulated CloudFormation replaces
+ * a changed Resource, so a modification it reports is always a replacement.
+ */
+export interface SimCfnResourceChange {
+    readonly action: SimCfnResourceChangeAction;
+    readonly logicalResourceId: string;
+    readonly resourceType: string | undefined;
+    readonly replacement: "True" | undefined;
+}

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

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

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

@@ -0,0 +1,53 @@
+import type { SimCloudFormationStackName } from "../stack/sim-cfn-stack.type.js";
+import type { SimCfnChangeSet } from "./sim-cfn-change-set.js";
+import type { SimCfnChangeSetName } from "./sim-cfn-change-set.type.js";
+/**
+ * How CloudFormation refuses a change set that cannot be executed.
+ */
+export declare function simCfnChangeSetNotExecutable(changeSet: SimCfnChangeSet): Error;
+interface SimCfnChangeSetLookup {
+    /** A change set name, or the change set ARN CreateChangeSet returned. */
+    readonly changeSetName: string;
+    /** The Stack the change set belongs to, needed alongside a plain name. */
+    readonly stackName?: string | undefined;
+}
+/**
+ * The change sets one simulated CloudFormation holds, in the order they were
+ * created.
+ *
+ * A change set is reached by its ARN on its own, or by its name together with
+ * the Stack it belongs to, which is how CloudFormation reaches one. Two change
+ * sets against different Stacks can carry the same name.
+ */
+export declare class SimCfnChangeSets {
+    private changeSets;
+    /** Hold a change set that has just been created. */
+    add(changeSet: SimCfnChangeSet): void;
+    /** Find a change set, or answer undefined where the lookup names none. */
+    find(lookup: SimCfnChangeSetLookup): SimCfnChangeSet | undefined;
+    /**
+     * Find a change set, refusing a lookup that names none the way
+     * CloudFormation refuses it.
+     */
+    require(lookup: SimCfnChangeSetLookup): SimCfnChangeSet;
+    /**
+     * Find a change set that can be executed, refusing one that cannot.
+     *
+     * A change set that failed to build, that has already been executed, or that
+     * another execution has made obsolete is refused for the status it is in,
+     * the way CloudFormation refuses it.
+     */
+    requireExecutable(lookup: SimCfnChangeSetLookup): SimCfnChangeSet;
+    /** Whether this Stack already holds a change set under this name. */
+    has(stackName: SimCloudFormationStackName, name: SimCfnChangeSetName): boolean;
+    /** The change sets held against one Stack, in the order they were created. */
+    forStack(stackName: SimCloudFormationStackName): readonly SimCfnChangeSet[];
+    /** Take a change set away, for DeleteChangeSet. */
+    remove(changeSet: SimCfnChangeSet): void;
+    /**
+     * Give up on every other change set against this Stack, because the one
+     * given has been executed and the Stack has moved on from what they saw.
+     */
+    markOthersObsolete(executed: SimCfnChangeSet): void;
+}
+export {};