aws-cdk 0.0.0

package/lib/api/util/cloudformation/stack-event-poller.d.ts

@@ -0,0 +1,63 @@
+import type { StackEvent } from '@aws-sdk/client-cloudformation';
+import type { ICloudFormationClient } from '../../aws-auth';
+export interface StackEventPollerProps {
+    /**
+     * The stack to poll
+     */
+    readonly stackName: string;
+    /**
+     * IDs of parent stacks of this resource, in case of resources in nested stacks
+     */
+    readonly parentStackLogicalIds?: string[];
+    /**
+     * Timestamp for the oldest event we're interested in
+     *
+     * @default - Read all events
+     */
+    readonly startTime?: number;
+    /**
+     * Stop reading when we see the stack entering this status
+     *
+     * Should be something like `CREATE_IN_PROGRESS`, `UPDATE_IN_PROGRESS`,
+     * `DELETE_IN_PROGRESS, `ROLLBACK_IN_PROGRESS`.
+     *
+     * @default - Read all events
+     */
+    readonly stackStatuses?: string[];
+}
+export interface ResourceEvent {
+    readonly event: StackEvent;
+    readonly parentStackLogicalIds: string[];
+    /**
+     * Whether this event regards the root stack
+     *
+     * @default false
+     */
+    readonly isStackEvent?: boolean;
+}
+export declare class StackEventPoller {
+    private readonly cfn;
+    private readonly props;
+    readonly events: ResourceEvent[];
+    complete: boolean;
+    private readonly eventIds;
+    private readonly nestedStackPollers;
+    constructor(cfn: ICloudFormationClient, props: StackEventPollerProps);
+    /**
+     * From all accumulated events, return only the errors
+     */
+    get resourceErrors(): ResourceEvent[];
+    /**
+     * Poll for new stack events
+     *
+     * Will not return events older than events indicated by the constructor filters.
+     *
+     * Recurses into nested stacks, and returns events old-to-new.
+     */
+    poll(): Promise<ResourceEvent[]>;
+    private doPoll;
+    /**
+     * On the CREATE_IN_PROGRESS, UPDATE_IN_PROGRESS, DELETE_IN_PROGRESS event of a nested stack, poll the nested stack updates
+     */
+    private trackNestedStack;
+}

package/lib/api/util/cloudformation/stack-event-poller.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StackEventPoller = void 0;
+const error_1 = require("../../../util/error");
+class StackEventPoller {
+    constructor(cfn, props) {
+        this.cfn = cfn;
+        this.props = props;
+        this.events = [];
+        this.complete = false;
+        this.eventIds = new Set();
+        this.nestedStackPollers = {};
+    }
+    /**
+     * From all accumulated events, return only the errors
+     */
+    get resourceErrors() {
+        return this.events.filter((e) => { var _a; return ((_a = e.event.ResourceStatus) === null || _a === void 0 ? void 0 : _a.endsWith('_FAILED')) && !e.isStackEvent; });
+    }
+    /**
+     * Poll for new stack events
+     *
+     * Will not return events older than events indicated by the constructor filters.
+     *
+     * Recurses into nested stacks, and returns events old-to-new.
+     */
+    async poll() {
+        const events = await this.doPoll();
+        // Also poll all nested stacks we're currently tracking
+        for (const [logicalId, poller] of Object.entries(this.nestedStackPollers)) {
+            events.push(...(await poller.poll()));
+            if (poller.complete) {
+                delete this.nestedStackPollers[logicalId];
+            }
+        }
+        // Return what we have so far
+        events.sort((a, b) => a.event.Timestamp.valueOf() - b.event.Timestamp.valueOf());
+        this.events.push(...events);
+        return events;
+    }
+    async doPoll() {
+        var _a, _b, _c, _d, _e, _f;
+        const events = [];
+        try {
+            let nextToken;
+            let finished = false;
+            while (!finished) {
+                const page = await this.cfn.describeStackEvents({ StackName: this.props.stackName, NextToken: nextToken });
+                for (const event of (_a = page === null || page === void 0 ? void 0 : page.StackEvents) !== null && _a !== void 0 ? _a : []) {
+                    // Event from before we were interested in 'em
+                    if (this.props.startTime !== undefined && event.Timestamp.valueOf() < this.props.startTime) {
+                        return events;
+                    }
+                    // Already seen this one
+                    if (this.eventIds.has(event.EventId)) {
+                        return events;
+                    }
+                    this.eventIds.add(event.EventId);
+                    // The events for the stack itself are also included next to events about resources; we can test for them in this way.
+                    const isParentStackEvent = event.PhysicalResourceId === event.StackId;
+                    if (isParentStackEvent && ((_b = this.props.stackStatuses) === null || _b === void 0 ? void 0 : _b.includes((_c = event.ResourceStatus) !== null && _c !== void 0 ? _c : ''))) {
+                        return events;
+                    }
+                    // Fresh event
+                    const resEvent = {
+                        event: event,
+                        parentStackLogicalIds: (_d = this.props.parentStackLogicalIds) !== null && _d !== void 0 ? _d : [],
+                        isStackEvent: isParentStackEvent,
+                    };
+                    events.push(resEvent);
+                    if (!isParentStackEvent &&
+                        event.ResourceType === 'AWS::CloudFormation::Stack' &&
+                        isStackBeginOperationState(event.ResourceStatus)) {
+                        // If the event is not for `this` stack and has a physical resource Id, recursively call for events in the nested stack
+                        this.trackNestedStack(event, [...((_e = this.props.parentStackLogicalIds) !== null && _e !== void 0 ? _e : []), (_f = event.LogicalResourceId) !== null && _f !== void 0 ? _f : '']);
+                    }
+                    if (isParentStackEvent && isStackTerminalState(event.ResourceStatus)) {
+                        this.complete = true;
+                    }
+                }
+                nextToken = page === null || page === void 0 ? void 0 : page.NextToken;
+                if (nextToken === undefined) {
+                    finished = true;
+                }
+            }
+        }
+        catch (e) {
+            if (!(e.name === 'ValidationError' && (0, error_1.formatErrorMessage)(e) === `Stack [${this.props.stackName}] does not exist`)) {
+                throw e;
+            }
+        }
+        return events;
+    }
+    /**
+     * On the CREATE_IN_PROGRESS, UPDATE_IN_PROGRESS, DELETE_IN_PROGRESS event of a nested stack, poll the nested stack updates
+     */
+    trackNestedStack(event, parentStackLogicalIds) {
+        const logicalId = event.LogicalResourceId;
+        const physicalResourceId = event.PhysicalResourceId;
+        // The CREATE_IN_PROGRESS event for a Nested Stack is emitted twice; first without a PhysicalResourceId
+        // and then with. Ignore this event if we don't have that property yet.
+        //
+        // (At this point, I also don't trust that logicalId is always going to be there so validate that as well)
+        if (!logicalId || !physicalResourceId) {
+            return;
+        }
+        if (!this.nestedStackPollers[logicalId]) {
+            this.nestedStackPollers[logicalId] = new StackEventPoller(this.cfn, {
+                stackName: physicalResourceId,
+                parentStackLogicalIds: parentStackLogicalIds,
+                startTime: event.Timestamp.valueOf(),
+            });
+        }
+    }
+}
+exports.StackEventPoller = StackEventPoller;
+function isStackBeginOperationState(state) {
+    return [
+        'CREATE_IN_PROGRESS',
+        'UPDATE_IN_PROGRESS',
+        'DELETE_IN_PROGRESS',
+        'UPDATE_ROLLBACK_IN_PROGRESS',
+        'ROLLBACK_IN_PROGRESS',
+    ].includes(state !== null && state !== void 0 ? state : '');
+}
+function isStackTerminalState(state) {
+    return !(state !== null && state !== void 0 ? state : '').endsWith('_IN_PROGRESS');
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stack-event-poller.js","sourceRoot":"","sources":["stack-event-poller.ts"],"names":[],"mappings":"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","sourcesContent":["import type { StackEvent } from '@aws-sdk/client-cloudformation';\nimport { formatErrorMessage } from '../../../util/error';\nimport type { ICloudFormationClient } from '../../aws-auth';\n\nexport interface StackEventPollerProps {\n  /**\n   * The stack to poll\n   */\n  readonly stackName: string;\n\n  /**\n   * IDs of parent stacks of this resource, in case of resources in nested stacks\n   */\n  readonly parentStackLogicalIds?: string[];\n\n  /**\n   * Timestamp for the oldest event we're interested in\n   *\n   * @default - Read all events\n   */\n  readonly startTime?: number;\n\n  /**\n   * Stop reading when we see the stack entering this status\n   *\n   * Should be something like `CREATE_IN_PROGRESS`, `UPDATE_IN_PROGRESS`,\n   * `DELETE_IN_PROGRESS, `ROLLBACK_IN_PROGRESS`.\n   *\n   * @default - Read all events\n   */\n  readonly stackStatuses?: string[];\n}\n\nexport interface ResourceEvent {\n  readonly event: StackEvent;\n  readonly parentStackLogicalIds: string[];\n\n  /**\n   * Whether this event regards the root stack\n   *\n   * @default false\n   */\n  readonly isStackEvent?: boolean;\n}\n\nexport class StackEventPoller {\n  public readonly events: ResourceEvent[] = [];\n  public complete: boolean = false;\n\n  private readonly eventIds = new Set<string>();\n  private readonly nestedStackPollers: Record<string, StackEventPoller> = {};\n\n  constructor(\n    private readonly cfn: ICloudFormationClient,\n    private readonly props: StackEventPollerProps,\n  ) {}\n\n  /**\n   * From all accumulated events, return only the errors\n   */\n  public get resourceErrors(): ResourceEvent[] {\n    return this.events.filter((e) => e.event.ResourceStatus?.endsWith('_FAILED') && !e.isStackEvent);\n  }\n\n  /**\n   * Poll for new stack events\n   *\n   * Will not return events older than events indicated by the constructor filters.\n   *\n   * Recurses into nested stacks, and returns events old-to-new.\n   */\n  public async poll(): Promise<ResourceEvent[]> {\n    const events: ResourceEvent[] = await this.doPoll();\n\n    // Also poll all nested stacks we're currently tracking\n    for (const [logicalId, poller] of Object.entries(this.nestedStackPollers)) {\n      events.push(...(await poller.poll()));\n      if (poller.complete) {\n        delete this.nestedStackPollers[logicalId];\n      }\n    }\n\n    // Return what we have so far\n    events.sort((a, b) => a.event.Timestamp!.valueOf() - b.event.Timestamp!.valueOf());\n    this.events.push(...events);\n    return events;\n  }\n\n  private async doPoll(): Promise<ResourceEvent[]> {\n    const events: ResourceEvent[] = [];\n    try {\n      let nextToken: string | undefined;\n      let finished = false;\n\n      while (!finished) {\n        const page = await this.cfn.describeStackEvents({ StackName: this.props.stackName, NextToken: nextToken });\n        for (const event of page?.StackEvents ?? []) {\n          // Event from before we were interested in 'em\n          if (this.props.startTime !== undefined && event.Timestamp!.valueOf() < this.props.startTime) {\n            return events;\n          }\n\n          // Already seen this one\n          if (this.eventIds.has(event.EventId!)) {\n            return events;\n          }\n          this.eventIds.add(event.EventId!);\n\n          // The events for the stack itself are also included next to events about resources; we can test for them in this way.\n          const isParentStackEvent = event.PhysicalResourceId === event.StackId;\n\n          if (isParentStackEvent && this.props.stackStatuses?.includes(event.ResourceStatus ?? '')) {\n            return events;\n          }\n\n          // Fresh event\n          const resEvent: ResourceEvent = {\n            event: event,\n            parentStackLogicalIds: this.props.parentStackLogicalIds ?? [],\n            isStackEvent: isParentStackEvent,\n          };\n          events.push(resEvent);\n\n          if (\n            !isParentStackEvent &&\n              event.ResourceType === 'AWS::CloudFormation::Stack' &&\n              isStackBeginOperationState(event.ResourceStatus)\n          ) {\n            // If the event is not for `this` stack and has a physical resource Id, recursively call for events in the nested stack\n            this.trackNestedStack(event, [...(this.props.parentStackLogicalIds ?? []), event.LogicalResourceId ?? '']);\n          }\n\n          if (isParentStackEvent && isStackTerminalState(event.ResourceStatus)) {\n            this.complete = true;\n          }\n        }\n\n        nextToken = page?.NextToken;\n        if (nextToken === undefined) {\n          finished = true;\n        }\n\n      }\n    } catch (e: any) {\n      if (!(e.name === 'ValidationError' && formatErrorMessage(e) === `Stack [${this.props.stackName}] does not exist`)) {\n        throw e;\n      }\n    }\n\n    return events;\n  }\n\n  /**\n   * On the CREATE_IN_PROGRESS, UPDATE_IN_PROGRESS, DELETE_IN_PROGRESS event of a nested stack, poll the nested stack updates\n   */\n  private trackNestedStack(event: StackEvent, parentStackLogicalIds: string[]) {\n    const logicalId = event.LogicalResourceId;\n    const physicalResourceId = event.PhysicalResourceId;\n\n    // The CREATE_IN_PROGRESS event for a Nested Stack is emitted twice; first without a PhysicalResourceId\n    // and then with. Ignore this event if we don't have that property yet.\n    //\n    // (At this point, I also don't trust that logicalId is always going to be there so validate that as well)\n    if (!logicalId || !physicalResourceId) {\n      return;\n    }\n\n    if (!this.nestedStackPollers[logicalId]) {\n      this.nestedStackPollers[logicalId] = new StackEventPoller(this.cfn, {\n        stackName: physicalResourceId,\n        parentStackLogicalIds: parentStackLogicalIds,\n        startTime: event.Timestamp!.valueOf(),\n      });\n    }\n  }\n}\n\nfunction isStackBeginOperationState(state: string | undefined) {\n  return [\n    'CREATE_IN_PROGRESS',\n    'UPDATE_IN_PROGRESS',\n    'DELETE_IN_PROGRESS',\n    'UPDATE_ROLLBACK_IN_PROGRESS',\n    'ROLLBACK_IN_PROGRESS',\n  ].includes(state ?? '');\n}\n\nfunction isStackTerminalState(state: string | undefined) {\n  return !(state ?? '').endsWith('_IN_PROGRESS');\n}\n"]}

package/lib/api/util/cloudformation/stack-status.d.ts

@@ -0,0 +1,42 @@
+import { type Stack } from '@aws-sdk/client-cloudformation';
+/**
+ * A utility class to inspect CloudFormation stack statuses.
+ *
+ * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-describing-stacks.html
+ */
+export declare class StackStatus {
+    readonly name: string;
+    readonly reason?: string | undefined;
+    static fromStackDescription(description: Stack): StackStatus;
+    constructor(name: string, reason?: string | undefined);
+    get isCreationFailure(): boolean;
+    get isDeleted(): boolean;
+    get isFailure(): boolean;
+    get isInProgress(): boolean;
+    get isReviewInProgress(): boolean;
+    get isNotFound(): boolean;
+    get isDeploySuccess(): boolean;
+    get isRollbackSuccess(): boolean;
+    /**
+     * Whether the stack is in a paused state due to `--no-rollback`.
+     *
+     * The possible actions here are retrying a new `--no-rollback` deployment, or initiating a rollback.
+     */
+    get rollbackChoice(): RollbackChoice;
+    get isRollbackable(): boolean;
+    toString(): string;
+}
+/**
+ * Describe the current rollback options for this state
+ */
+export declare enum RollbackChoice {
+    START_ROLLBACK = 0,
+    CONTINUE_UPDATE_ROLLBACK = 1,
+    /**
+     * A sign that stack creation AND its rollback have failed.
+     *
+     * There is no way to recover from this, other than recreating the stack.
+     */
+    ROLLBACK_FAILED = 2,
+    NONE = 3
+}

package/lib/api/util/cloudformation/stack-status.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RollbackChoice = exports.StackStatus = void 0;
+const client_cloudformation_1 = require("@aws-sdk/client-cloudformation");
+/**
+ * A utility class to inspect CloudFormation stack statuses.
+ *
+ * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-describing-stacks.html
+ */
+class StackStatus {
+    static fromStackDescription(description) {
+        return new StackStatus(description.StackStatus, description.StackStatusReason);
+    }
+    constructor(name, reason) {
+        this.name = name;
+        this.reason = reason;
+    }
+    get isCreationFailure() {
+        return this.name === client_cloudformation_1.StackStatus.ROLLBACK_COMPLETE || this.name === client_cloudformation_1.StackStatus.ROLLBACK_FAILED;
+    }
+    get isDeleted() {
+        return this.name.startsWith('DELETE_');
+    }
+    get isFailure() {
+        return this.name.endsWith('FAILED');
+    }
+    get isInProgress() {
+        return this.name.endsWith('_IN_PROGRESS') && !this.isReviewInProgress;
+    }
+    get isReviewInProgress() {
+        return this.name === client_cloudformation_1.StackStatus.REVIEW_IN_PROGRESS;
+    }
+    get isNotFound() {
+        return this.name === 'NOT_FOUND';
+    }
+    get isDeploySuccess() {
+        return (!this.isNotFound &&
+            (this.name === client_cloudformation_1.StackStatus.CREATE_COMPLETE ||
+                this.name === client_cloudformation_1.StackStatus.UPDATE_COMPLETE ||
+                this.name === client_cloudformation_1.StackStatus.IMPORT_COMPLETE));
+    }
+    get isRollbackSuccess() {
+        return this.name === client_cloudformation_1.StackStatus.ROLLBACK_COMPLETE || this.name === client_cloudformation_1.StackStatus.UPDATE_ROLLBACK_COMPLETE;
+    }
+    /**
+     * Whether the stack is in a paused state due to `--no-rollback`.
+     *
+     * The possible actions here are retrying a new `--no-rollback` deployment, or initiating a rollback.
+     */
+    get rollbackChoice() {
+        switch (this.name) {
+            case client_cloudformation_1.StackStatus.CREATE_FAILED:
+            case client_cloudformation_1.StackStatus.UPDATE_FAILED:
+                return RollbackChoice.START_ROLLBACK;
+            case client_cloudformation_1.StackStatus.UPDATE_ROLLBACK_FAILED:
+                return RollbackChoice.CONTINUE_UPDATE_ROLLBACK;
+            case client_cloudformation_1.StackStatus.ROLLBACK_FAILED:
+                // Unfortunately there is no option to continue a failed rollback without
+                // a stable target state.
+                return RollbackChoice.ROLLBACK_FAILED;
+            default:
+                return RollbackChoice.NONE;
+        }
+    }
+    get isRollbackable() {
+        return [RollbackChoice.START_ROLLBACK, RollbackChoice.CONTINUE_UPDATE_ROLLBACK].includes(this.rollbackChoice);
+    }
+    toString() {
+        return this.name + (this.reason ? ` (${this.reason})` : '');
+    }
+}
+exports.StackStatus = StackStatus;
+/**
+ * Describe the current rollback options for this state
+ */
+var RollbackChoice;
+(function (RollbackChoice) {
+    RollbackChoice[RollbackChoice["START_ROLLBACK"] = 0] = "START_ROLLBACK";
+    RollbackChoice[RollbackChoice["CONTINUE_UPDATE_ROLLBACK"] = 1] = "CONTINUE_UPDATE_ROLLBACK";
+    /**
+     * A sign that stack creation AND its rollback have failed.
+     *
+     * There is no way to recover from this, other than recreating the stack.
+     */
+    RollbackChoice[RollbackChoice["ROLLBACK_FAILED"] = 2] = "ROLLBACK_FAILED";
+    RollbackChoice[RollbackChoice["NONE"] = 3] = "NONE";
+})(RollbackChoice || (exports.RollbackChoice = RollbackChoice = {}));
+//# sourceMappingURL=data:application/json;base64,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

package/lib/api/util/display.d.ts

@@ -0,0 +1,13 @@
+/**
+ * A class representing rewritable display lines
+ */
+export declare class RewritableBlock {
+    private readonly stream;
+    private lastHeight;
+    private trailingEmptyLines;
+    constructor(stream: NodeJS.WriteStream);
+    get width(): number;
+    get height(): number;
+    displayLines(lines: string[]): void;
+    removeEmptyLines(): void;
+}

package/lib/api/util/display.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RewritableBlock = void 0;
+// namespace object imports won't work in the bundle for function exports
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const wrapAnsi = require('wrap-ansi');
+/**
+ * A class representing rewritable display lines
+ */
+class RewritableBlock {
+    constructor(stream) {
+        this.stream = stream;
+        this.lastHeight = 0;
+        this.trailingEmptyLines = 0;
+    }
+    get width() {
+        // Might get changed if the user resizes the terminal
+        return this.stream.columns;
+    }
+    get height() {
+        // Might get changed if the user resizes the terminal
+        return this.stream.rows;
+    }
+    displayLines(lines) {
+        lines = terminalWrap(this.width, expandNewlines(lines));
+        lines = lines.slice(0, getMaxBlockHeight(this.height, this.lastHeight, lines));
+        this.stream.write(cursorUp(this.lastHeight));
+        for (const line of lines) {
+            this.stream.write(cll() + line + '\n');
+        }
+        this.trailingEmptyLines = Math.max(0, this.lastHeight - lines.length);
+        // Clear remainder of unwritten lines
+        for (let i = 0; i < this.trailingEmptyLines; i++) {
+            this.stream.write(cll() + '\n');
+        }
+        // The block can only ever get bigger
+        this.lastHeight = Math.max(this.lastHeight, lines.length);
+    }
+    removeEmptyLines() {
+        this.stream.write(cursorUp(this.trailingEmptyLines));
+    }
+}
+exports.RewritableBlock = RewritableBlock;
+const ESC = '\u001b';
+/*
+ * Move cursor up `n` lines. Default is 1
+ */
+function cursorUp(n) {
+    n = typeof n === 'number' ? n : 1;
+    return n > 0 ? ESC + '[' + n + 'A' : '';
+}
+/**
+ * Clear to end of line
+ */
+function cll() {
+    return ESC + '[K';
+}
+function terminalWrap(width, lines) {
+    if (width === undefined) {
+        return lines;
+    }
+    return lines.flatMap(line => wrapAnsi(line, width - 1, {
+        hard: true,
+        trim: true,
+        wordWrap: false,
+    }).split('\n'));
+}
+/**
+ * Make sure there are no hidden newlines in the gin strings
+ */
+function expandNewlines(lines) {
+    return lines.flatMap(line => line.split('\n'));
+}
+function getMaxBlockHeight(windowHeight, lastHeight, lines) {
+    if (windowHeight === undefined) {
+        return Math.max(lines.length, lastHeight);
+    }
+    return lines.length < windowHeight ? lines.length : windowHeight - 1;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/api/util/placeholders.d.ts

@@ -0,0 +1,10 @@
+import { type Environment } from '@aws-cdk/cx-api';
+import { Branded } from '../../util/type-brands';
+import type { SdkProvider } from '../aws-auth/sdk-provider';
+/**
+ * Replace the {ACCOUNT} and {REGION} placeholders in all strings found in a complex object.
+ */
+export declare function replaceEnvPlaceholders<A extends Record<string, string | undefined>>(object: A, env: Environment, sdkProvider: SdkProvider): Promise<{
+    [k in keyof A]: StringWithoutPlaceholders | undefined;
+}>;
+export type StringWithoutPlaceholders = Branded<string, 'NoPlaceholders'>;

package/lib/api/util/placeholders.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replaceEnvPlaceholders = replaceEnvPlaceholders;
+const cx_api_1 = require("@aws-cdk/cx-api");
+const mode_1 = require("../plugin/mode");
+/**
+ * Replace the {ACCOUNT} and {REGION} placeholders in all strings found in a complex object.
+ */
+async function replaceEnvPlaceholders(object, env, sdkProvider) {
+    return cx_api_1.EnvironmentPlaceholders.replaceAsync(object, {
+        accountId: () => Promise.resolve(env.account),
+        region: () => Promise.resolve(env.region),
+        partition: async () => {
+            var _a;
+            // There's no good way to get the partition!
+            // We should have had it already, except we don't.
+            //
+            // Best we can do is ask the "base credentials" for this environment for their partition. Cross-partition
+            // AssumeRole'ing will never work anyway, so this answer won't be wrong (it will just be slow!)
+            return (_a = (await sdkProvider.baseCredentialsPartition(env, mode_1.Mode.ForReading))) !== null && _a !== void 0 ? _a : 'aws';
+        },
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/api/util/rwlock.d.ts

@@ -0,0 +1,65 @@
+/**
+ * A single-writer/multi-reader lock on a directory
+ *
+ * It uses marker files with PIDs in them as a locking marker; the PIDs will be
+ * checked for liveness, so that if the process exits without cleaning up the
+ * files the lock is implicitly released.
+ *
+ * This class is not 100% race safe, but in practice it should be a lot
+ * better than the 0 protection we have today.
+ */
+export declare class RWLock {
+    readonly directory: string;
+    private readonly pidString;
+    private readonly writerFile;
+    private readCounter;
+    constructor(directory: string);
+    /**
+     * Acquire a writer lock.
+     *
+     * No other readers or writers must exist for the given directory.
+     */
+    acquireWrite(): Promise<IWriterLock>;
+    /**
+     * Acquire a read lock
+     *
+     * Will fail if there are any writers.
+     */
+    acquireRead(): Promise<ILock>;
+    /**
+     * Obtains the name fo a (new) `readerFile` to use. This includes a counter so
+     * that if multiple threads of the same PID attempt to concurrently acquire
+     * the same lock, they're guaranteed to use a different reader file name (only
+     * one thread will ever execute JS code at once, guaranteeing the readCounter
+     * is incremented "atomically" from the point of view of this PID.).
+     */
+    private readerFile;
+    /**
+     * Do the actual acquiring of a read lock.
+     */
+    private doAcquireRead;
+    private assertNoOtherWriters;
+    /**
+     * Check the current writer (if any)
+     */
+    private currentWriter;
+    /**
+     * Check the current readers (if any)
+     */
+    private currentReaders;
+}
+/**
+ * An acquired lock
+ */
+export interface ILock {
+    release(): Promise<void>;
+}
+/**
+ * An acquired writer lock
+ */
+export interface IWriterLock extends ILock {
+    /**
+     * Convert the writer lock to a reader lock
+     */
+    convertToReaderLock(): Promise<ILock>;
+}