aws-cdk 0.0.0

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

@@ -0,0 +1,21 @@
+import { GcAsset as GCAsset } from './garbage-collector';
+export declare class ProgressPrinter {
+    private totalAssets;
+    private assetsScanned;
+    private taggedAsset;
+    private taggedAssetsSizeMb;
+    private deletedAssets;
+    private deletedAssetsSizeMb;
+    private interval;
+    private setInterval?;
+    private isPaused;
+    constructor(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,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProgressPrinter = void 0;
+const chalk = require("chalk");
+const logging_1 = require("../../logging");
+const error_1 = require("../../toolkit/error");
+class ProgressPrinter {
+    constructor(totalAssets, interval) {
+        this.totalAssets = totalAssets;
+        this.assetsScanned = 0;
+        this.taggedAsset = 0;
+        this.taggedAssetsSizeMb = 0;
+        this.deletedAssets = 0;
+        this.deletedAssetsSizeMb = 0;
+        this.interval = interval !== null && interval !== void 0 ? interval : 10000;
+        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 / 1048576;
+    }
+    reportDeletedAsset(assets) {
+        this.deletedAssets += assets.length;
+        const sizeInBytes = assets.reduce((total, asset) => total + asset.size, 0);
+        this.deletedAssetsSizeMb += sizeInBytes / 1048576;
+    }
+    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 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) {
+            (0, logging_1.info)(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 {
+            (0, logging_1.info)(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,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

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

@@ -0,0 +1,44 @@
+import { ICloudFormationClient } from '../aws-auth';
+export declare class ActiveAssetCache {
+    private readonly stacks;
+    rememberStack(stackTemplate: string): void;
+    contains(asset: string): boolean;
+}
+export declare function refreshStacks(cfn: ICloudFormationClient, activeAssets: ActiveAssetCache, qualifier?: string): Promise<void>;
+/**
+ * Background Stack Refresh properties
+ */
+export interface BackgroundStackRefreshProps {
+    /**
+     * The CFN SDK handler
+     */
+    readonly cfn: ICloudFormationClient;
+    /**
+     * 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,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BackgroundStackRefresh = exports.ActiveAssetCache = void 0;
+exports.refreshStacks = refreshStacks;
+const logging_1 = require("../../logging");
+const error_1 = require("../../toolkit/error");
+class ActiveAssetCache {
+    constructor() {
+        this.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, qualifier) {
+    var _a;
+    const stackNames = [];
+    await paginateSdkCall(async (nextToken) => {
+        var _a;
+        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(...((_a = stacks.StackSummaries) !== null && _a !== void 0 ? _a : [])
+            .filter((s) => !ignoredStatues.includes(s.StackStatus))
+            .map((s) => { var _a; return (_a = s.StackId) !== null && _a !== void 0 ? _a : s.StackName; }));
+        return stacks.NextToken;
+    });
+    (0, logging_1.debug)(`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(((_a = template.TemplateBody) !== null && _a !== void 0 ? _a : '') + JSON.stringify(summary === null || summary === void 0 ? void 0 : summary.Parameters));
+        }
+    }
+    (0, logging_1.debug)('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) {
+    var _a;
+    const bootstrapVersion = parameters === null || parameters === void 0 ? void 0 : parameters.find((p) => p.ParameterKey === 'BootstrapVersion');
+    const splitBootstrapVersion = (_a = bootstrapVersion === null || bootstrapVersion === void 0 ? void 0 : bootstrapVersion.DefaultValue) === null || _a === void 0 ? void 0 : _a.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, activeAssets, qualifier) {
+    try {
+        const stacks = await fetchAllStackTemplates(cfn, qualifier);
+        for (const stack of stacks) {
+            activeAssets.rememberStack(stack);
+        }
+    }
+    catch (err) {
+        throw new error_1.ToolkitError(`Error refreshing stacks: ${err}`);
+    }
+}
+/**
+ * Class that controls scheduling of the background stack refresh
+ */
+class BackgroundStackRefresh {
+    constructor(props) {
+        this.props = props;
+        this.queuedPromises = [];
+        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(), 300000); // 5 minutes
+    }
+    async refresh() {
+        const startTime = Date.now();
+        await refreshStacks(this.props.cfn, 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 + 300000 - 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 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 { ParameterDeclaration } from '@aws-sdk/client-cloudformation';\nimport { debug } from '../../logging';\nimport { ToolkitError } from '../../toolkit/error';\nimport { ICloudFormationClient } from '../aws-auth';\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, 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  debug(`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  debug('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, activeAssets: ActiveAssetCache, qualifier?: string) {\n  try {\n    const stacks = await fetchAllStackTemplates(cfn, 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   * 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.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,3 @@
+import { type ChangeHotswapResult, type HotswappableChangeCandidate } from './common';
+import type { EvaluateCloudFormationTemplate } from '../evaluate-cloudformation-template';
+export declare function isHotswappableAppSyncChange(logicalId: string, change: HotswappableChangeCandidate, evaluateCfnTemplate: EvaluateCloudFormationTemplate): Promise<ChangeHotswapResult>;

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

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isHotswappableAppSyncChange = isHotswappableAppSyncChange;
+const common_1 = require("./common");
+const error_1 = require("../../toolkit/error");
+async function isHotswappableAppSyncChange(logicalId, change, evaluateCfnTemplate) {
+    var _a;
+    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 ? (_a = change.newValue.Properties) === null || _a === void 0 ? void 0 : _a.Name : undefined);
+        if (isResolver) {
+            const arnParts = arn === null || arn === void 0 ? void 0 : arn.split('/');
+            physicalName = arnParts ? `${arnParts[3]}.${arnParts[5]}` : undefined;
+        }
+        else {
+            physicalName = arn;
+        }
+        ret.push({
+            hotswappable: true,
+            resourceType: change.newValue.Type,
+            propsChanged: namesOfHotswappableChanges,
+            service: 'appsync',
+            resourceNames: [`${change.newValue.Type} '${physicalName}'`],
+            apply: async (sdk) => {
+                var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+                if (!physicalName) {
+                    return;
+                }
+                const sdkProperties = {
+                    ...change.oldValue.Properties,
+                    Definition: (_a = change.newValue.Properties) === null || _a === void 0 ? void 0 : _a.Definition,
+                    DefinitionS3Location: (_b = change.newValue.Properties) === null || _b === void 0 ? void 0 : _b.DefinitionS3Location,
+                    requestMappingTemplate: (_c = change.newValue.Properties) === null || _c === void 0 ? void 0 : _c.RequestMappingTemplate,
+                    requestMappingTemplateS3Location: (_d = change.newValue.Properties) === null || _d === void 0 ? void 0 : _d.RequestMappingTemplateS3Location,
+                    responseMappingTemplate: (_e = change.newValue.Properties) === null || _e === void 0 ? void 0 : _e.ResponseMappingTemplate,
+                    responseMappingTemplateS3Location: (_f = change.newValue.Properties) === null || _f === void 0 ? void 0 : _f.ResponseMappingTemplateS3Location,
+                    code: (_g = change.newValue.Properties) === null || _g === void 0 ? void 0 : _g.Code,
+                    codeS3Location: (_h = change.newValue.Properties) === null || _h === void 0 ? void 0 : _h.CodeS3Location,
+                    expires: (_j = change.newValue.Properties) === null || _j === void 0 ? void 0 : _j.Expires,
+                };
+                const evaluatedResourceProperties = await evaluateCfnTemplate.evaluateCfnExpression(sdkProperties);
+                const sdkRequestObject = (0, common_1.transformObjectKeys)(evaluatedResourceProperties, common_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 } = (_k = functions.find((fn) => fn.name === physicalName)) !== null && _k !== void 0 ? _k : {};
+                    // 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 error_1.ToolkitError((_l = schemaCreationResponse.details) !== null && _l !== void 0 ? _l : '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 === null || physicalName === void 0 ? void 0 : physicalName.split('/');
+                        if (arnParts && arnParts.length === 4) {
+                            sdkRequestObject.id = arnParts[3];
+                        }
+                    }
+                    await sdk.appsync().updateApiKey(sdkRequestObject);
+                }
+            },
+        });
+    }
+    return ret;
+}
+async function fetchFileFromS3(s3Url, sdk) {
+    var _a;
+    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 (_a = (await sdk.s3().getObject({ Bucket: s3Bucket, Key: s3Key })).Body) === null || _a === void 0 ? void 0 : _a.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 ChangeHotswapResult,\n  classifyChanges,\n  type HotswappableChangeCandidate,\n  lowerCaseFirstCharacter,\n  transformObjectKeys,\n} from './common';\nimport { ToolkitError } from '../../toolkit/error';\nimport type { SDK } from '../aws-auth';\n\nimport type { EvaluateCloudFormationTemplate } from '../evaluate-cloudformation-template';\n\nexport async function isHotswappableAppSyncChange(\n  logicalId: string,\n  change: HotswappableChangeCandidate,\n  evaluateCfnTemplate: EvaluateCloudFormationTemplate,\n): Promise<ChangeHotswapResult> {\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: ChangeHotswapResult = [];\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    ret.push({\n      hotswappable: true,\n      resourceType: change.newValue.Type,\n      propsChanged: namesOfHotswappableChanges,\n      service: 'appsync',\n      resourceNames: [`${change.newValue.Type} '${physicalName}'`],\n      apply: async (sdk: SDK) => {\n        if (!physicalName) {\n          return;\n        }\n\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,3 @@
+import { type ChangeHotswapResult, type HotswappableChangeCandidate } from './common';
+import type { EvaluateCloudFormationTemplate } from '../evaluate-cloudformation-template';
+export declare function isHotswappableCodeBuildProjectChange(logicalId: string, change: HotswappableChangeCandidate, evaluateCfnTemplate: EvaluateCloudFormationTemplate): Promise<ChangeHotswapResult>;

package/lib/api/hotswap/code-build-projects.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isHotswappableCodeBuildProjectChange = isHotswappableCodeBuildProjectChange;
+const common_1 = require("./common");
+async function isHotswappableCodeBuildProjectChange(logicalId, change, evaluateCfnTemplate) {
+    var _a;
+    if (change.newValue.Type !== 'AWS::CodeBuild::Project') {
+        return [];
+    }
+    const ret = [];
+    const classifiedChanges = (0, common_1.classifyChanges)(change, ['Source', 'Environment', 'SourceVersion']);
+    classifiedChanges.reportNonHotswappablePropertyChanges(ret);
+    if (classifiedChanges.namesOfHotswappableProps.length > 0) {
+        const updateProjectInput = {
+            name: '',
+        };
+        const projectName = await evaluateCfnTemplate.establishResourcePhysicalName(logicalId, (_a = change.newValue.Properties) === null || _a === void 0 ? void 0 : _a.Name);
+        ret.push({
+            hotswappable: true,
+            resourceType: change.newValue.Type,
+            propsChanged: classifiedChanges.namesOfHotswappableProps,
+            service: 'codebuild',
+            resourceNames: [`CodeBuild Project '${projectName}'`],
+            apply: async (sdk) => {
+                if (!projectName) {
+                    return;
+                }
+                updateProjectInput.name = projectName;
+                for (const updatedPropName in change.propertyUpdates) {
+                    const updatedProp = change.propertyUpdates[updatedPropName];
+                    switch (updatedPropName) {
+                        case 'Source':
+                            updateProjectInput.source = (0, common_1.transformObjectKeys)(await evaluateCfnTemplate.evaluateCfnExpression(updatedProp.newValue), convertSourceCloudformationKeyToSdkKey);
+                            break;
+                        case 'Environment':
+                            updateProjectInput.environment = await (0, common_1.transformObjectKeys)(await evaluateCfnTemplate.evaluateCfnExpression(updatedProp.newValue), common_1.lowerCaseFirstCharacter);
+                            break;
+                        case 'SourceVersion':
+                            updateProjectInput.sourceVersion = await evaluateCfnTemplate.evaluateCfnExpression(updatedProp.newValue);
+                            break;
+                    }
+                }
+                await sdk.codeBuild().updateProject(updateProjectInput);
+            },
+        });
+    }
+    return ret;
+}
+function convertSourceCloudformationKeyToSdkKey(key) {
+    if (key.toLowerCase() === 'buildspec') {
+        return key.toLowerCase();
+    }
+    return (0, common_1.lowerCaseFirstCharacter)(key);
+}
+//# sourceMappingURL=data:application/json;base64,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