@aws-cdk/toolkit-lib 0.3.2 → 0.3.3

package/lib/api/garbage-collection/index.d.ts

@@ -0,0 +1,3 @@
+export * from './garbage-collector';
+export * from './progress-printer';
+export * from './stack-refresh';

package/lib/api/garbage-collection/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./garbage-collector"), exports);
+// testing exports
+__exportStar(require("./progress-printer"), exports);
+__exportStar(require("./stack-refresh"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsc0RBQW9DO0FBRXBDLGtCQUFrQjtBQUNsQixxREFBbUM7QUFDbkMsa0RBQWdDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9nYXJiYWdlLWNvbGxlY3Rvcic7XG5cbi8vIHRlc3RpbmcgZXhwb3J0c1xuZXhwb3J0ICogZnJvbSAnLi9wcm9ncmVzcy1wcmludGVyJztcbmV4cG9ydCAqIGZyb20gJy4vc3RhY2stcmVmcmVzaCc7XG4iXX0=

package/lib/api/garbage-collection/progress-printer.d.ts

@@ -0,0 +1,23 @@
+import type { GcAsset as GCAsset } from './garbage-collector';
+import { type IoHelper } from '../io/private';
+export declare class ProgressPrinter {
+    private ioHelper;
+    private totalAssets;
+    private assetsScanned;
+    private taggedAsset;
+    private taggedAssetsSizeMb;
+    private deletedAssets;
+    private deletedAssetsSizeMb;
+    private interval;
+    private setInterval?;
+    private isPaused;
+    constructor(ioHelper: IoHelper, totalAssets: number, interval?: number);
+    reportScannedAsset(amt: number): void;
+    reportTaggedAsset(assets: GCAsset[]): void;
+    reportDeletedAsset(assets: GCAsset[]): void;
+    start(): void;
+    pause(): void;
+    resume(): void;
+    stop(): void;
+    private print;
+}

package/lib/api/garbage-collection/progress-printer.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProgressPrinter = void 0;
+const chalk = require("chalk");
+const private_1 = require("../io/private");
+const toolkit_error_1 = require("../toolkit-error");
+class ProgressPrinter {
+    ioHelper;
+    totalAssets;
+    assetsScanned;
+    taggedAsset;
+    taggedAssetsSizeMb;
+    deletedAssets;
+    deletedAssetsSizeMb;
+    interval;
+    setInterval;
+    isPaused;
+    constructor(ioHelper, totalAssets, interval) {
+        this.ioHelper = ioHelper;
+        this.totalAssets = totalAssets;
+        this.assetsScanned = 0;
+        this.taggedAsset = 0;
+        this.taggedAssetsSizeMb = 0;
+        this.deletedAssets = 0;
+        this.deletedAssetsSizeMb = 0;
+        this.interval = interval ?? 10_000;
+        this.isPaused = false;
+    }
+    reportScannedAsset(amt) {
+        this.assetsScanned += amt;
+    }
+    reportTaggedAsset(assets) {
+        this.taggedAsset += assets.length;
+        const sizeInBytes = assets.reduce((total, asset) => total + asset.size, 0);
+        this.taggedAssetsSizeMb += sizeInBytes / 1_048_576;
+    }
+    reportDeletedAsset(assets) {
+        this.deletedAssets += assets.length;
+        const sizeInBytes = assets.reduce((total, asset) => total + asset.size, 0);
+        this.deletedAssetsSizeMb += sizeInBytes / 1_048_576;
+    }
+    start() {
+        // If there is already a running setInterval, throw an error.
+        // This is because if this.setInterval is reassigned to another setInterval,
+        // the original setInterval remains and can no longer be cleared.
+        if (this.setInterval) {
+            throw new toolkit_error_1.ToolkitError('ProgressPrinter is already running. Stop it first using the stop() method before starting it again.');
+        }
+        this.setInterval = setInterval(() => {
+            if (!this.isPaused) {
+                this.print();
+            }
+        }, this.interval);
+    }
+    pause() {
+        this.isPaused = true;
+    }
+    resume() {
+        this.isPaused = false;
+    }
+    stop() {
+        clearInterval(this.setInterval);
+        // print one last time if not paused
+        if (!this.isPaused) {
+            this.print();
+        }
+    }
+    print() {
+        const percentage = ((this.assetsScanned / this.totalAssets) * 100).toFixed(2);
+        // print in MiB until we hit at least 1 GiB of data tagged/deleted
+        if (Math.max(this.taggedAssetsSizeMb, this.deletedAssetsSizeMb) >= 1000) {
+            void this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_INFO.msg(chalk.green(`[${percentage}%] ${this.assetsScanned} files scanned: ${this.taggedAsset} assets (${(this.taggedAssetsSizeMb / 1000).toFixed(2)} GiB) tagged, ${this.deletedAssets} assets (${(this.deletedAssetsSizeMb / 1000).toFixed(2)} GiB) deleted.`)));
+        }
+        else {
+            void this.ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_INFO.msg(chalk.green(`[${percentage}%] ${this.assetsScanned} files scanned: ${this.taggedAsset} assets (${this.taggedAssetsSizeMb.toFixed(2)} MiB) tagged, ${this.deletedAssets} assets (${this.deletedAssetsSizeMb.toFixed(2)} MiB) deleted.`)));
+        }
+    }
+}
+exports.ProgressPrinter = ProgressPrinter;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"progress-printer.js","sourceRoot":"","sources":["progress-printer.ts"],"names":[],"mappings":"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","sourcesContent":["import * as chalk from 'chalk';\nimport type { GcAsset as GCAsset } from './garbage-collector';\nimport { IO, type IoHelper } from '../io/private';\nimport { ToolkitError } from '../toolkit-error';\n\nexport class ProgressPrinter {\n  private ioHelper: IoHelper;\n  private totalAssets: number;\n  private assetsScanned: number;\n  private taggedAsset: number;\n  private taggedAssetsSizeMb: number;\n  private deletedAssets: number;\n  private deletedAssetsSizeMb: number;\n  private interval: number;\n  private setInterval?: ReturnType<typeof setTimeout>;\n  private isPaused: boolean;\n\n  constructor(ioHelper: IoHelper, totalAssets: number, interval?: number) {\n    this.ioHelper = ioHelper;\n    this.totalAssets = totalAssets;\n    this.assetsScanned = 0;\n    this.taggedAsset = 0;\n    this.taggedAssetsSizeMb = 0;\n    this.deletedAssets = 0;\n    this.deletedAssetsSizeMb = 0;\n    this.interval = interval ?? 10_000;\n    this.isPaused = false;\n  }\n\n  public reportScannedAsset(amt: number) {\n    this.assetsScanned += amt;\n  }\n\n  public reportTaggedAsset(assets: GCAsset[]) {\n    this.taggedAsset += assets.length;\n    const sizeInBytes = assets.reduce((total, asset) => total + asset.size, 0);\n    this.taggedAssetsSizeMb += sizeInBytes / 1_048_576;\n  }\n\n  public reportDeletedAsset(assets: GCAsset[]) {\n    this.deletedAssets += assets.length;\n    const sizeInBytes = assets.reduce((total, asset) => total + asset.size, 0);\n    this.deletedAssetsSizeMb += sizeInBytes / 1_048_576;\n  }\n\n  public start() {\n    // If there is already a running setInterval, throw an error.\n    // This is because if this.setInterval is reassigned to another setInterval,\n    // the original setInterval remains and can no longer be cleared.\n    if (this.setInterval) {\n      throw new ToolkitError('ProgressPrinter is already running. Stop it first using the stop() method before starting it again.');\n    }\n\n    this.setInterval = setInterval(() => {\n      if (!this.isPaused) {\n        this.print();\n      }\n    }, this.interval);\n  }\n\n  public pause() {\n    this.isPaused = true;\n  }\n\n  public resume() {\n    this.isPaused = false;\n  }\n\n  public stop() {\n    clearInterval(this.setInterval);\n    // print one last time if not paused\n    if (!this.isPaused) {\n      this.print();\n    }\n  }\n\n  private print() {\n    const percentage = ((this.assetsScanned / this.totalAssets) * 100).toFixed(2);\n    // print in MiB until we hit at least 1 GiB of data tagged/deleted\n    if (Math.max(this.taggedAssetsSizeMb, this.deletedAssetsSizeMb) >= 1000) {\n      void this.ioHelper.notify(IO.DEFAULT_TOOLKIT_INFO.msg(chalk.green(`[${percentage}%] ${this.assetsScanned} files scanned: ${this.taggedAsset} assets (${(this.taggedAssetsSizeMb / 1000).toFixed(2)} GiB) tagged, ${this.deletedAssets} assets (${(this.deletedAssetsSizeMb / 1000).toFixed(2)} GiB) deleted.`)));\n    } else {\n      void this.ioHelper.notify(IO.DEFAULT_TOOLKIT_INFO.msg(chalk.green(`[${percentage}%] ${this.assetsScanned} files scanned: ${this.taggedAsset} assets (${this.taggedAssetsSizeMb.toFixed(2)} MiB) tagged, ${this.deletedAssets} assets (${this.deletedAssetsSizeMb.toFixed(2)} MiB) deleted.`)));\n    }\n  }\n}\n"]}

package/lib/api/garbage-collection/stack-refresh.d.ts

@@ -0,0 +1,49 @@
+import type { ICloudFormationClient } from '../aws-auth/private';
+import { type IoHelper } from '../io/private';
+export declare class ActiveAssetCache {
+    private readonly stacks;
+    rememberStack(stackTemplate: string): void;
+    contains(asset: string): boolean;
+}
+export declare function refreshStacks(cfn: ICloudFormationClient, ioHelper: IoHelper, activeAssets: ActiveAssetCache, qualifier?: string): Promise<void>;
+/**
+ * Background Stack Refresh properties
+ */
+export interface BackgroundStackRefreshProps {
+    /**
+     * The CFN SDK handler
+     */
+    readonly cfn: ICloudFormationClient;
+    /**
+     * Used to send messages.
+     */
+    readonly ioHelper: IoHelper;
+    /**
+     * Active Asset storage
+     */
+    readonly activeAssets: ActiveAssetCache;
+    /**
+     * Stack bootstrap qualifier
+     */
+    readonly qualifier?: string;
+}
+/**
+ * Class that controls scheduling of the background stack refresh
+ */
+export declare class BackgroundStackRefresh {
+    private readonly props;
+    private timeout?;
+    private lastRefreshTime;
+    private queuedPromises;
+    constructor(props: BackgroundStackRefreshProps);
+    start(): void;
+    private refresh;
+    private justRefreshedStacks;
+    /**
+     * Checks if the last successful background refresh happened within the specified time frame.
+     * If the last refresh is older than the specified time frame, it returns a Promise that resolves
+     * when the next background refresh completes or rejects if the refresh takes too long.
+     */
+    noOlderThan(ms: number): Promise<unknown>;
+    stop(): void;
+}

package/lib/api/garbage-collection/stack-refresh.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BackgroundStackRefresh = exports.ActiveAssetCache = void 0;
+exports.refreshStacks = refreshStacks;
+const private_1 = require("../io/private");
+const toolkit_error_1 = require("../toolkit-error");
+class ActiveAssetCache {
+    stacks = new Set();
+    rememberStack(stackTemplate) {
+        this.stacks.add(stackTemplate);
+    }
+    contains(asset) {
+        for (const stack of this.stacks) {
+            if (stack.includes(asset)) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+exports.ActiveAssetCache = ActiveAssetCache;
+async function paginateSdkCall(cb) {
+    let finished = false;
+    let nextToken;
+    while (!finished) {
+        nextToken = await cb(nextToken);
+        if (nextToken === undefined) {
+            finished = true;
+        }
+    }
+}
+/**
+ * Fetches all relevant stack templates from CloudFormation. It ignores the following stacks:
+ * - stacks in DELETE_COMPLETE or DELETE_IN_PROGRESS stage
+ * - stacks that are using a different bootstrap qualifier
+ */
+async function fetchAllStackTemplates(cfn, ioHelper, qualifier) {
+    const stackNames = [];
+    await paginateSdkCall(async (nextToken) => {
+        const stacks = await cfn.listStacks({ NextToken: nextToken });
+        // We ignore stacks with these statuses because their assets are no longer live
+        const ignoredStatues = ['CREATE_FAILED', 'DELETE_COMPLETE', 'DELETE_IN_PROGRESS', 'DELETE_FAILED', 'REVIEW_IN_PROGRESS'];
+        stackNames.push(...(stacks.StackSummaries ?? [])
+            .filter((s) => !ignoredStatues.includes(s.StackStatus))
+            .map((s) => s.StackId ?? s.StackName));
+        return stacks.NextToken;
+    });
+    await ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_DEBUG.msg(`Parsing through ${stackNames.length} stacks`));
+    const templates = [];
+    for (const stack of stackNames) {
+        let summary;
+        summary = await cfn.getTemplateSummary({
+            StackName: stack,
+        });
+        if (bootstrapFilter(summary.Parameters, qualifier)) {
+            // This stack is definitely bootstrapped to a different qualifier so we can safely ignore it
+            continue;
+        }
+        else {
+            const template = await cfn.getTemplate({
+                StackName: stack,
+            });
+            templates.push((template.TemplateBody ?? '') + JSON.stringify(summary?.Parameters));
+        }
+    }
+    await ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_DEBUG.msg('Done parsing through stacks'));
+    return templates;
+}
+/**
+ * Filter out stacks that we KNOW are using a different bootstrap qualifier
+ * This is mostly necessary for the integration tests that can run the same app (with the same assets)
+ * under different qualifiers.
+ * This is necessary because a stack under a different bootstrap could coincidentally reference the same hash
+ * and cause a false negative (cause an asset to be preserved when its isolated)
+ * This is intentionally done in a way where we ONLY filter out stacks that are meant for a different qualifier
+ * because we are okay with false positives.
+ */
+function bootstrapFilter(parameters, qualifier) {
+    const bootstrapVersion = parameters?.find((p) => p.ParameterKey === 'BootstrapVersion');
+    const splitBootstrapVersion = bootstrapVersion?.DefaultValue?.split('/');
+    // We find the qualifier in a specific part of the bootstrap version parameter
+    return (qualifier &&
+        splitBootstrapVersion &&
+        splitBootstrapVersion.length == 4 &&
+        splitBootstrapVersion[2] != qualifier);
+}
+async function refreshStacks(cfn, ioHelper, activeAssets, qualifier) {
+    try {
+        const stacks = await fetchAllStackTemplates(cfn, ioHelper, qualifier);
+        for (const stack of stacks) {
+            activeAssets.rememberStack(stack);
+        }
+    }
+    catch (err) {
+        throw new toolkit_error_1.ToolkitError(`Error refreshing stacks: ${err}`);
+    }
+}
+/**
+ * Class that controls scheduling of the background stack refresh
+ */
+class BackgroundStackRefresh {
+    props;
+    timeout;
+    lastRefreshTime;
+    queuedPromises = [];
+    constructor(props) {
+        this.props = props;
+        this.lastRefreshTime = Date.now();
+    }
+    start() {
+        // Since start is going to be called right after the first invocation of refreshStacks,
+        // lets wait some time before beginning the background refresh.
+        this.timeout = setTimeout(() => this.refresh(), 300_000); // 5 minutes
+    }
+    async refresh() {
+        const startTime = Date.now();
+        await refreshStacks(this.props.cfn, this.props.ioHelper, this.props.activeAssets, this.props.qualifier);
+        this.justRefreshedStacks();
+        // If the last invocation of refreshStacks takes <5 minutes, the next invocation starts 5 minutes after the last one started.
+        // If the last invocation of refreshStacks takes >5 minutes, the next invocation starts immediately.
+        this.timeout = setTimeout(() => this.refresh(), Math.max(startTime + 300_000 - Date.now(), 0));
+    }
+    justRefreshedStacks() {
+        this.lastRefreshTime = Date.now();
+        for (const p of this.queuedPromises.splice(0, this.queuedPromises.length)) {
+            p(undefined);
+        }
+    }
+    /**
+     * Checks if the last successful background refresh happened within the specified time frame.
+     * If the last refresh is older than the specified time frame, it returns a Promise that resolves
+     * when the next background refresh completes or rejects if the refresh takes too long.
+     */
+    noOlderThan(ms) {
+        const horizon = Date.now() - ms;
+        // The last refresh happened within the time frame
+        if (this.lastRefreshTime >= horizon) {
+            return Promise.resolve();
+        }
+        // The last refresh happened earlier than the time frame
+        // We will wait for the latest refresh to land or reject if it takes too long
+        return Promise.race([
+            new Promise(resolve => this.queuedPromises.push(resolve)),
+            new Promise((_, reject) => setTimeout(() => reject(new toolkit_error_1.ToolkitError('refreshStacks took too long; the background thread likely threw an error')), ms)),
+        ]);
+    }
+    stop() {
+        clearTimeout(this.timeout);
+    }
+}
+exports.BackgroundStackRefresh = BackgroundStackRefresh;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stack-refresh.js","sourceRoot":"","sources":["stack-refresh.ts"],"names":[],"mappings":"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","sourcesContent":["import type { ParameterDeclaration } from '@aws-sdk/client-cloudformation';\nimport type { ICloudFormationClient } from '../aws-auth/private';\nimport { IO, type IoHelper } from '../io/private';\nimport { ToolkitError } from '../toolkit-error';\n\nexport class ActiveAssetCache {\n  private readonly stacks: Set<string> = new Set();\n\n  public rememberStack(stackTemplate: string) {\n    this.stacks.add(stackTemplate);\n  }\n\n  public contains(asset: string): boolean {\n    for (const stack of this.stacks) {\n      if (stack.includes(asset)) {\n        return true;\n      }\n    }\n    return false;\n  }\n}\n\nasync function paginateSdkCall(cb: (nextToken?: string) => Promise<string | undefined>) {\n  let finished = false;\n  let nextToken: string | undefined;\n  while (!finished) {\n    nextToken = await cb(nextToken);\n    if (nextToken === undefined) {\n      finished = true;\n    }\n  }\n}\n\n/**\n * Fetches all relevant stack templates from CloudFormation. It ignores the following stacks:\n * - stacks in DELETE_COMPLETE or DELETE_IN_PROGRESS stage\n * - stacks that are using a different bootstrap qualifier\n */\nasync function fetchAllStackTemplates(cfn: ICloudFormationClient, ioHelper: IoHelper, qualifier?: string) {\n  const stackNames: string[] = [];\n  await paginateSdkCall(async (nextToken) => {\n    const stacks = await cfn.listStacks({ NextToken: nextToken });\n\n    // We ignore stacks with these statuses because their assets are no longer live\n    const ignoredStatues = ['CREATE_FAILED', 'DELETE_COMPLETE', 'DELETE_IN_PROGRESS', 'DELETE_FAILED', 'REVIEW_IN_PROGRESS'];\n    stackNames.push(\n      ...(stacks.StackSummaries ?? [])\n        .filter((s: any) => !ignoredStatues.includes(s.StackStatus))\n        .map((s: any) => s.StackId ?? s.StackName),\n    );\n\n    return stacks.NextToken;\n  });\n\n  await ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(`Parsing through ${stackNames.length} stacks`));\n\n  const templates: string[] = [];\n  for (const stack of stackNames) {\n    let summary;\n    summary = await cfn.getTemplateSummary({\n      StackName: stack,\n    });\n\n    if (bootstrapFilter(summary.Parameters, qualifier)) {\n      // This stack is definitely bootstrapped to a different qualifier so we can safely ignore it\n      continue;\n    } else {\n      const template = await cfn.getTemplate({\n        StackName: stack,\n      });\n\n      templates.push((template.TemplateBody ?? '') + JSON.stringify(summary?.Parameters));\n    }\n  }\n\n  await ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg('Done parsing through stacks'));\n\n  return templates;\n}\n\n/**\n * Filter out stacks that we KNOW are using a different bootstrap qualifier\n * This is mostly necessary for the integration tests that can run the same app (with the same assets)\n * under different qualifiers.\n * This is necessary because a stack under a different bootstrap could coincidentally reference the same hash\n * and cause a false negative (cause an asset to be preserved when its isolated)\n * This is intentionally done in a way where we ONLY filter out stacks that are meant for a different qualifier\n * because we are okay with false positives.\n */\nfunction bootstrapFilter(parameters?: ParameterDeclaration[], qualifier?: string) {\n  const bootstrapVersion = parameters?.find((p) => p.ParameterKey === 'BootstrapVersion');\n  const splitBootstrapVersion = bootstrapVersion?.DefaultValue?.split('/');\n  // We find the qualifier in a specific part of the bootstrap version parameter\n  return (qualifier &&\n          splitBootstrapVersion &&\n          splitBootstrapVersion.length == 4 &&\n          splitBootstrapVersion[2] != qualifier);\n}\n\nexport async function refreshStacks(cfn: ICloudFormationClient, ioHelper: IoHelper, activeAssets: ActiveAssetCache, qualifier?: string) {\n  try {\n    const stacks = await fetchAllStackTemplates(cfn, ioHelper, qualifier);\n    for (const stack of stacks) {\n      activeAssets.rememberStack(stack);\n    }\n  } catch (err) {\n    throw new ToolkitError(`Error refreshing stacks: ${err}`);\n  }\n}\n\n/**\n * Background Stack Refresh properties\n */\nexport interface BackgroundStackRefreshProps {\n  /**\n   * The CFN SDK handler\n   */\n  readonly cfn: ICloudFormationClient;\n\n  /**\n   * Used to send messages.\n   */\n  readonly ioHelper: IoHelper;\n\n  /**\n   * Active Asset storage\n   */\n  readonly activeAssets: ActiveAssetCache;\n\n  /**\n   * Stack bootstrap qualifier\n   */\n  readonly qualifier?: string;\n}\n\n/**\n * Class that controls scheduling of the background stack refresh\n */\nexport class BackgroundStackRefresh {\n  private timeout?: NodeJS.Timeout;\n  private lastRefreshTime: number;\n  private queuedPromises: Array<(value: unknown) => void> = [];\n\n  constructor(private readonly props: BackgroundStackRefreshProps) {\n    this.lastRefreshTime = Date.now();\n  }\n\n  public start() {\n    // Since start is going to be called right after the first invocation of refreshStacks,\n    // lets wait some time before beginning the background refresh.\n    this.timeout = setTimeout(() => this.refresh(), 300_000); // 5 minutes\n  }\n\n  private async refresh() {\n    const startTime = Date.now();\n\n    await refreshStacks(this.props.cfn, this.props.ioHelper, this.props.activeAssets, this.props.qualifier);\n    this.justRefreshedStacks();\n\n    // If the last invocation of refreshStacks takes <5 minutes, the next invocation starts 5 minutes after the last one started.\n    // If the last invocation of refreshStacks takes >5 minutes, the next invocation starts immediately.\n    this.timeout = setTimeout(() => this.refresh(), Math.max(startTime + 300_000 - Date.now(), 0));\n  }\n\n  private justRefreshedStacks() {\n    this.lastRefreshTime = Date.now();\n    for (const p of this.queuedPromises.splice(0, this.queuedPromises.length)) {\n      p(undefined);\n    }\n  }\n\n  /**\n   * Checks if the last successful background refresh happened within the specified time frame.\n   * If the last refresh is older than the specified time frame, it returns a Promise that resolves\n   * when the next background refresh completes or rejects if the refresh takes too long.\n   */\n  public noOlderThan(ms: number) {\n    const horizon = Date.now() - ms;\n\n    // The last refresh happened within the time frame\n    if (this.lastRefreshTime >= horizon) {\n      return Promise.resolve();\n    }\n\n    // The last refresh happened earlier than the time frame\n    // We will wait for the latest refresh to land or reject if it takes too long\n    return Promise.race([\n      new Promise(resolve => this.queuedPromises.push(resolve)),\n      new Promise((_, reject) => setTimeout(() => reject(new ToolkitError('refreshStacks took too long; the background thread likely threw an error')), ms)),\n    ]);\n  }\n\n  public stop() {\n    clearTimeout(this.timeout);\n  }\n}\n"]}

package/lib/api/hotswap/appsync-mapping-templates.d.ts

@@ -0,0 +1,4 @@
+import { type HotswapChange } from './common';
+import type { ResourceChange } from '../../payloads/hotswap';
+import type { EvaluateCloudFormationTemplate } from '../cloudformation';
+export declare function isHotswappableAppSyncChange(logicalId: string, change: ResourceChange, evaluateCfnTemplate: EvaluateCloudFormationTemplate): Promise<HotswapChange[]>;

package/lib/api/hotswap/appsync-mapping-templates.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isHotswappableAppSyncChange = isHotswappableAppSyncChange;
+const common_1 = require("./common");
+const util_1 = require("../../util");
+const toolkit_error_1 = require("../toolkit-error");
+async function isHotswappableAppSyncChange(logicalId, change, evaluateCfnTemplate) {
+    const isResolver = change.newValue.Type === 'AWS::AppSync::Resolver';
+    const isFunction = change.newValue.Type === 'AWS::AppSync::FunctionConfiguration';
+    const isGraphQLSchema = change.newValue.Type === 'AWS::AppSync::GraphQLSchema';
+    const isAPIKey = change.newValue.Type === 'AWS::AppSync::ApiKey';
+    if (!isResolver && !isFunction && !isGraphQLSchema && !isAPIKey) {
+        return [];
+    }
+    const ret = [];
+    const classifiedChanges = (0, common_1.classifyChanges)(change, [
+        'RequestMappingTemplate',
+        'RequestMappingTemplateS3Location',
+        'ResponseMappingTemplate',
+        'ResponseMappingTemplateS3Location',
+        'Code',
+        'CodeS3Location',
+        'Definition',
+        'DefinitionS3Location',
+        'Expires',
+    ]);
+    classifiedChanges.reportNonHotswappablePropertyChanges(ret);
+    const namesOfHotswappableChanges = Object.keys(classifiedChanges.hotswappableProps);
+    if (namesOfHotswappableChanges.length > 0) {
+        let physicalName = undefined;
+        const arn = await evaluateCfnTemplate.establishResourcePhysicalName(logicalId, isFunction ? change.newValue.Properties?.Name : undefined);
+        if (isResolver) {
+            const arnParts = arn?.split('/');
+            physicalName = arnParts ? `${arnParts[3]}.${arnParts[5]}` : undefined;
+        }
+        else {
+            physicalName = arn;
+        }
+        // nothing do here
+        if (!physicalName) {
+            return ret;
+        }
+        ret.push({
+            change: {
+                cause: change,
+                resources: [{
+                        logicalId,
+                        resourceType: change.newValue.Type,
+                        physicalName,
+                        metadata: evaluateCfnTemplate.metadataFor(logicalId),
+                    }],
+            },
+            hotswappable: true,
+            service: 'appsync',
+            apply: async (sdk) => {
+                const sdkProperties = {
+                    ...change.oldValue.Properties,
+                    Definition: change.newValue.Properties?.Definition,
+                    DefinitionS3Location: change.newValue.Properties?.DefinitionS3Location,
+                    requestMappingTemplate: change.newValue.Properties?.RequestMappingTemplate,
+                    requestMappingTemplateS3Location: change.newValue.Properties?.RequestMappingTemplateS3Location,
+                    responseMappingTemplate: change.newValue.Properties?.ResponseMappingTemplate,
+                    responseMappingTemplateS3Location: change.newValue.Properties?.ResponseMappingTemplateS3Location,
+                    code: change.newValue.Properties?.Code,
+                    codeS3Location: change.newValue.Properties?.CodeS3Location,
+                    expires: change.newValue.Properties?.Expires,
+                };
+                const evaluatedResourceProperties = await evaluateCfnTemplate.evaluateCfnExpression(sdkProperties);
+                const sdkRequestObject = (0, util_1.transformObjectKeys)(evaluatedResourceProperties, util_1.lowerCaseFirstCharacter);
+                // resolve s3 location files as SDK doesn't take in s3 location but inline code
+                if (sdkRequestObject.requestMappingTemplateS3Location) {
+                    sdkRequestObject.requestMappingTemplate = await fetchFileFromS3(sdkRequestObject.requestMappingTemplateS3Location, sdk);
+                    delete sdkRequestObject.requestMappingTemplateS3Location;
+                }
+                if (sdkRequestObject.responseMappingTemplateS3Location) {
+                    sdkRequestObject.responseMappingTemplate = await fetchFileFromS3(sdkRequestObject.responseMappingTemplateS3Location, sdk);
+                    delete sdkRequestObject.responseMappingTemplateS3Location;
+                }
+                if (sdkRequestObject.definitionS3Location) {
+                    sdkRequestObject.definition = await fetchFileFromS3(sdkRequestObject.definitionS3Location, sdk);
+                    delete sdkRequestObject.definitionS3Location;
+                }
+                if (sdkRequestObject.codeS3Location) {
+                    sdkRequestObject.code = await fetchFileFromS3(sdkRequestObject.codeS3Location, sdk);
+                    delete sdkRequestObject.codeS3Location;
+                }
+                if (isResolver) {
+                    await sdk.appsync().updateResolver(sdkRequestObject);
+                }
+                else if (isFunction) {
+                    // Function version is only applicable when using VTL and mapping templates
+                    // Runtime only applicable when using code (JS mapping templates)
+                    if (sdkRequestObject.code) {
+                        delete sdkRequestObject.functionVersion;
+                    }
+                    else {
+                        delete sdkRequestObject.runtime;
+                    }
+                    const functions = await sdk.appsync().listFunctions({ apiId: sdkRequestObject.apiId });
+                    const { functionId } = functions.find((fn) => fn.name === physicalName) ?? {};
+                    // Updating multiple functions at the same time or along with graphql schema results in `ConcurrentModificationException`
+                    await exponentialBackOffRetry(() => sdk.appsync().updateFunction({
+                        ...sdkRequestObject,
+                        functionId: functionId,
+                    }), 6, 1000, 'ConcurrentModificationException');
+                }
+                else if (isGraphQLSchema) {
+                    let schemaCreationResponse = await sdk
+                        .appsync()
+                        .startSchemaCreation(sdkRequestObject);
+                    while (schemaCreationResponse.status &&
+                        ['PROCESSING', 'DELETING'].some((status) => status === schemaCreationResponse.status)) {
+                        await sleep(1000); // poll every second
+                        const getSchemaCreationStatusRequest = {
+                            apiId: sdkRequestObject.apiId,
+                        };
+                        schemaCreationResponse = await sdk.appsync().getSchemaCreationStatus(getSchemaCreationStatusRequest);
+                    }
+                    if (schemaCreationResponse.status === 'FAILED') {
+                        throw new toolkit_error_1.ToolkitError(schemaCreationResponse.details ?? 'Schema creation has failed.');
+                    }
+                }
+                else {
+                    // isApiKey
+                    if (!sdkRequestObject.id) {
+                        // ApiKeyId is optional in CFN but required in SDK. Grab the KeyId from physicalArn if not available as part of CFN template
+                        const arnParts = physicalName?.split('/');
+                        if (arnParts && arnParts.length === 4) {
+                            sdkRequestObject.id = arnParts[3];
+                        }
+                    }
+                    await sdk.appsync().updateApiKey(sdkRequestObject);
+                }
+            },
+        });
+    }
+    return ret;
+}
+async function fetchFileFromS3(s3Url, sdk) {
+    const s3PathParts = s3Url.split('/');
+    const s3Bucket = s3PathParts[2]; // first two are "s3:" and "" due to s3://
+    const s3Key = s3PathParts.splice(3).join('/'); // after removing first three we reconstruct the key
+    return (await sdk.s3().getObject({ Bucket: s3Bucket, Key: s3Key })).Body?.transformToString();
+}
+async function exponentialBackOffRetry(fn, numOfRetries, backOff, errorCodeToRetry) {
+    try {
+        await fn();
+    }
+    catch (error) {
+        if (error && error.name === errorCodeToRetry && numOfRetries > 0) {
+            await sleep(backOff); // time to wait doubles everytime function fails, starts at 1 second
+            await exponentialBackOffRetry(fn, numOfRetries - 1, backOff * 2, errorCodeToRetry);
+        }
+        else {
+            throw error;
+        }
+    }
+}
+async function sleep(ms) {
+    return new Promise((ok) => setTimeout(ok, ms));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"appsync-mapping-templates.js","sourceRoot":"","sources":["appsync-mapping-templates.ts"],"names":[],"mappings":"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","sourcesContent":["import type {\n  GetSchemaCreationStatusCommandOutput,\n  GetSchemaCreationStatusCommandInput,\n} from '@aws-sdk/client-appsync';\nimport {\n  type HotswapChange,\n  classifyChanges,\n} from './common';\nimport type { ResourceChange } from '../../payloads/hotswap';\nimport { lowerCaseFirstCharacter, transformObjectKeys } from '../../util';\nimport type { SDK } from '../aws-auth/private';\n\nimport type { EvaluateCloudFormationTemplate } from '../cloudformation';\nimport { ToolkitError } from '../toolkit-error';\n\nexport async function isHotswappableAppSyncChange(\n  logicalId: string,\n  change: ResourceChange,\n  evaluateCfnTemplate: EvaluateCloudFormationTemplate,\n): Promise<HotswapChange[]> {\n  const isResolver = change.newValue.Type === 'AWS::AppSync::Resolver';\n  const isFunction = change.newValue.Type === 'AWS::AppSync::FunctionConfiguration';\n  const isGraphQLSchema = change.newValue.Type === 'AWS::AppSync::GraphQLSchema';\n  const isAPIKey = change.newValue.Type === 'AWS::AppSync::ApiKey';\n  if (!isResolver && !isFunction && !isGraphQLSchema && !isAPIKey) {\n    return [];\n  }\n\n  const ret: HotswapChange[] = [];\n\n  const classifiedChanges = classifyChanges(change, [\n    'RequestMappingTemplate',\n    'RequestMappingTemplateS3Location',\n    'ResponseMappingTemplate',\n    'ResponseMappingTemplateS3Location',\n    'Code',\n    'CodeS3Location',\n    'Definition',\n    'DefinitionS3Location',\n    'Expires',\n  ]);\n  classifiedChanges.reportNonHotswappablePropertyChanges(ret);\n\n  const namesOfHotswappableChanges = Object.keys(classifiedChanges.hotswappableProps);\n  if (namesOfHotswappableChanges.length > 0) {\n    let physicalName: string | undefined = undefined;\n    const arn = await evaluateCfnTemplate.establishResourcePhysicalName(\n      logicalId,\n      isFunction ? change.newValue.Properties?.Name : undefined,\n    );\n    if (isResolver) {\n      const arnParts = arn?.split('/');\n      physicalName = arnParts ? `${arnParts[3]}.${arnParts[5]}` : undefined;\n    } else {\n      physicalName = arn;\n    }\n\n    // nothing do here\n    if (!physicalName) {\n      return ret;\n    }\n\n    ret.push({\n      change: {\n        cause: change,\n        resources: [{\n          logicalId,\n          resourceType: change.newValue.Type,\n          physicalName,\n          metadata: evaluateCfnTemplate.metadataFor(logicalId),\n        }],\n      },\n      hotswappable: true,\n      service: 'appsync',\n      apply: async (sdk: SDK) => {\n        const sdkProperties: { [name: string]: any } = {\n          ...change.oldValue.Properties,\n          Definition: change.newValue.Properties?.Definition,\n          DefinitionS3Location: change.newValue.Properties?.DefinitionS3Location,\n          requestMappingTemplate: change.newValue.Properties?.RequestMappingTemplate,\n          requestMappingTemplateS3Location: change.newValue.Properties?.RequestMappingTemplateS3Location,\n          responseMappingTemplate: change.newValue.Properties?.ResponseMappingTemplate,\n          responseMappingTemplateS3Location: change.newValue.Properties?.ResponseMappingTemplateS3Location,\n          code: change.newValue.Properties?.Code,\n          codeS3Location: change.newValue.Properties?.CodeS3Location,\n          expires: change.newValue.Properties?.Expires,\n        };\n        const evaluatedResourceProperties = await evaluateCfnTemplate.evaluateCfnExpression(sdkProperties);\n        const sdkRequestObject = transformObjectKeys(evaluatedResourceProperties, lowerCaseFirstCharacter);\n\n        // resolve s3 location files as SDK doesn't take in s3 location but inline code\n        if (sdkRequestObject.requestMappingTemplateS3Location) {\n          sdkRequestObject.requestMappingTemplate = await fetchFileFromS3(\n            sdkRequestObject.requestMappingTemplateS3Location,\n            sdk,\n          );\n          delete sdkRequestObject.requestMappingTemplateS3Location;\n        }\n        if (sdkRequestObject.responseMappingTemplateS3Location) {\n          sdkRequestObject.responseMappingTemplate = await fetchFileFromS3(\n            sdkRequestObject.responseMappingTemplateS3Location,\n            sdk,\n          );\n          delete sdkRequestObject.responseMappingTemplateS3Location;\n        }\n        if (sdkRequestObject.definitionS3Location) {\n          sdkRequestObject.definition = await fetchFileFromS3(sdkRequestObject.definitionS3Location, sdk);\n          delete sdkRequestObject.definitionS3Location;\n        }\n        if (sdkRequestObject.codeS3Location) {\n          sdkRequestObject.code = await fetchFileFromS3(sdkRequestObject.codeS3Location, sdk);\n          delete sdkRequestObject.codeS3Location;\n        }\n\n        if (isResolver) {\n          await sdk.appsync().updateResolver(sdkRequestObject);\n        } else if (isFunction) {\n          // Function version is only applicable when using VTL and mapping templates\n          // Runtime only applicable when using code (JS mapping templates)\n          if (sdkRequestObject.code) {\n            delete sdkRequestObject.functionVersion;\n          } else {\n            delete sdkRequestObject.runtime;\n          }\n\n          const functions = await sdk.appsync().listFunctions({ apiId: sdkRequestObject.apiId });\n          const { functionId } = functions.find((fn) => fn.name === physicalName) ?? {};\n          // Updating multiple functions at the same time or along with graphql schema results in `ConcurrentModificationException`\n          await exponentialBackOffRetry(\n            () =>\n              sdk.appsync().updateFunction({\n                ...sdkRequestObject,\n                functionId: functionId,\n              }),\n            6,\n            1000,\n            'ConcurrentModificationException',\n          );\n        } else if (isGraphQLSchema) {\n          let schemaCreationResponse: GetSchemaCreationStatusCommandOutput = await sdk\n            .appsync()\n            .startSchemaCreation(sdkRequestObject);\n          while (\n            schemaCreationResponse.status &&\n            ['PROCESSING', 'DELETING'].some((status) => status === schemaCreationResponse.status)\n          ) {\n            await sleep(1000); // poll every second\n            const getSchemaCreationStatusRequest: GetSchemaCreationStatusCommandInput = {\n              apiId: sdkRequestObject.apiId,\n            };\n            schemaCreationResponse = await sdk.appsync().getSchemaCreationStatus(getSchemaCreationStatusRequest);\n          }\n          if (schemaCreationResponse.status === 'FAILED') {\n            throw new ToolkitError(schemaCreationResponse.details ?? 'Schema creation has failed.');\n          }\n        } else {\n          // isApiKey\n          if (!sdkRequestObject.id) {\n            // ApiKeyId is optional in CFN but required in SDK. Grab the KeyId from physicalArn if not available as part of CFN template\n            const arnParts = physicalName?.split('/');\n            if (arnParts && arnParts.length === 4) {\n              sdkRequestObject.id = arnParts[3];\n            }\n          }\n          await sdk.appsync().updateApiKey(sdkRequestObject);\n        }\n      },\n    });\n  }\n\n  return ret;\n}\n\nasync function fetchFileFromS3(s3Url: string, sdk: SDK) {\n  const s3PathParts = s3Url.split('/');\n  const s3Bucket = s3PathParts[2]; // first two are \"s3:\" and \"\" due to s3://\n  const s3Key = s3PathParts.splice(3).join('/'); // after removing first three we reconstruct the key\n  return (await sdk.s3().getObject({ Bucket: s3Bucket, Key: s3Key })).Body?.transformToString();\n}\n\nasync function exponentialBackOffRetry(fn: () => Promise<any>, numOfRetries: number, backOff: number, errorCodeToRetry: string) {\n  try {\n    await fn();\n  } catch (error: any) {\n    if (error && error.name === errorCodeToRetry && numOfRetries > 0) {\n      await sleep(backOff); // time to wait doubles everytime function fails, starts at 1 second\n      await exponentialBackOffRetry(fn, numOfRetries - 1, backOff * 2, errorCodeToRetry);\n    } else {\n      throw error;\n    }\n  }\n}\n\nasync function sleep(ms: number) {\n  return new Promise((ok) => setTimeout(ok, ms));\n}\n"]}

package/lib/api/hotswap/code-build-projects.d.ts

@@ -0,0 +1,4 @@
+import { type HotswapChange } from './common';
+import type { ResourceChange } from '../../payloads/hotswap';
+import type { EvaluateCloudFormationTemplate } from '../cloudformation';
+export declare function isHotswappableCodeBuildProjectChange(logicalId: string, change: ResourceChange, evaluateCfnTemplate: EvaluateCloudFormationTemplate): Promise<HotswapChange[]>;