sst 2.29.0 → 2.30.1

package/cdk/deploy-stack.d.ts

@@ -2,8 +2,8 @@ import * as cxapi from "@aws-cdk/cx-api";
 import { Tag } from "sst-aws-cdk/lib/cdk-toolkit.js";
 import { AssetManifestBuilder } from "sst-aws-cdk/lib/util/asset-manifest-builder.js";
 import { ISDK, SdkProvider } from "sst-aws-cdk/lib/api/aws-auth/index.js";
+import { EnvironmentResources } from "sst-aws-cdk/lib/api/environment-resources.js";
 import { HotswapMode } from "sst-aws-cdk/lib/api/hotswap/common.js";
-import { ToolkitInfo } from "sst-aws-cdk/lib/api/toolkit-info.js";
 import { ResourcesToImport } from "sst-aws-cdk/lib/api/util/cloudformation.js";
 import { StackActivityProgress } from "sst-aws-cdk/lib/api/util/cloudformation/stack-activity-monitor.js";
 type TemplateBodyParameter = {
@@ -56,7 +56,7 @@ export interface DeployStackOptions {
     /**
      * Information about the bootstrap stack found in the target environment
      */
-    readonly toolkitInfo: ToolkitInfo;
+    readonly envResources: EnvironmentResources;
     /**
      * Role to pass to CloudFormation to execute the change set
      *
@@ -200,14 +200,14 @@ export declare function deployStack(options: DeployStackOptions): Promise<Deploy
  * @param stack     the synthesized stack that provides the CloudFormation template
  * @param toolkitInfo information about the toolkit stack
  */
-export declare function makeBodyParameter(stack: cxapi.CloudFormationStackArtifact, resolvedEnvironment: cxapi.Environment, assetManifest: AssetManifestBuilder, toolkitInfo: ToolkitInfo, sdk: ISDK, overrideTemplate?: any): Promise<TemplateBodyParameter>;
+export declare function makeBodyParameter(stack: cxapi.CloudFormationStackArtifact, resolvedEnvironment: cxapi.Environment, assetManifest: AssetManifestBuilder, resources: EnvironmentResources, sdk: ISDK, overrideTemplate?: any): Promise<TemplateBodyParameter>;
 /**
  * Prepare a body parameter for CFN, performing the upload
  *
  * Return it as-is if it is small enough to pass in the API call,
  * upload to S3 and return the coordinates if it is not.
  */
-export declare function makeBodyParameterAndUpload(stack: cxapi.CloudFormationStackArtifact, resolvedEnvironment: cxapi.Environment, toolkitInfo: ToolkitInfo, sdkProvider: SdkProvider, sdk: ISDK, overrideTemplate?: any): Promise<TemplateBodyParameter>;
+export declare function makeBodyParameterAndUpload(stack: cxapi.CloudFormationStackArtifact, resolvedEnvironment: cxapi.Environment, resources: EnvironmentResources, sdkProvider: SdkProvider, sdk: ISDK, overrideTemplate?: any): Promise<TemplateBodyParameter>;
 export interface DestroyStackOptions {
     /**
      * The stack to be destroyed

package/cdk/deploy-stack.js

@@ -37,7 +37,7 @@ export async function deployStack(options) {
     // an ad-hoc asset manifest, while passing their locations via template
     // parameters.
     const legacyAssets = new AssetManifestBuilder();
-    const assetParams = await addMetadataAssetsToManifest(stackArtifact, legacyAssets, options.toolkitInfo, options.reuseAssets);
+    const assetParams = await addMetadataAssetsToManifest(stackArtifact, legacyAssets, options.envResources, options.reuseAssets);
     const finalParameterValues = { ...options.parameters, ...assetParams };
     const templateParams = TemplateParameters.fromTemplate(stackArtifact.template);
     const stackParams = options.usePreviousParameters
@@ -58,7 +58,7 @@ export async function deployStack(options) {
     else {
         debug(`${deployName}: deploying...`);
     }
-    const bodyParameter = await makeBodyParameter(stackArtifact, options.resolvedEnvironment, legacyAssets, options.toolkitInfo, options.sdk, options.overrideTemplate);
+    const bodyParameter = await makeBodyParameter(stackArtifact, options.resolvedEnvironment, legacyAssets, options.envResources, options.sdk, options.overrideTemplate);
     await publishAssets(legacyAssets.toManifest(stackArtifact.assembly.directory), options.sdkProvider, stackEnv, {
         parallel: options.assetParallelism,
     });
@@ -352,7 +352,7 @@ class FullCloudFormationDeployment {
  * @param stack     the synthesized stack that provides the CloudFormation template
  * @param toolkitInfo information about the toolkit stack
  */
-export async function makeBodyParameter(stack, resolvedEnvironment, assetManifest, toolkitInfo, sdk, overrideTemplate) {
+export async function makeBodyParameter(stack, resolvedEnvironment, assetManifest, resources, sdk, overrideTemplate) {
     // If the template has already been uploaded to S3, just use it from there.
     if (stack.stackTemplateAssetObjectUrl && !overrideTemplate) {
         return {
@@ -364,6 +364,7 @@ export async function makeBodyParameter(stack, resolvedEnvironment, assetManifes
     if (templateJson.length <= LARGE_TEMPLATE_SIZE_KB * 1024) {
         return { TemplateBody: templateJson };
     }
+    const toolkitInfo = await resources.lookupToolkit();
     if (!toolkitInfo.found) {
         error(`The template for stack "${stack.displayName}" is ${Math.round(templateJson.length / 1024)}KiB. ` +
             `Templates larger than ${LARGE_TEMPLATE_SIZE_KB}KiB must be uploaded to S3.\n` +
@@ -394,14 +395,14 @@ export async function makeBodyParameter(stack, resolvedEnvironment, assetManifes
  * Return it as-is if it is small enough to pass in the API call,
  * upload to S3 and return the coordinates if it is not.
  */
-export async function makeBodyParameterAndUpload(stack, resolvedEnvironment, toolkitInfo, sdkProvider, sdk, overrideTemplate) {
+export async function makeBodyParameterAndUpload(stack, resolvedEnvironment, resources, sdkProvider, sdk, overrideTemplate) {
     // We don't have access to the actual asset manifest here, so pretend that the
     // stack doesn't have a pre-published URL.
     const forceUploadStack = Object.create(stack, {
         stackTemplateAssetObjectUrl: { value: undefined },
     });
     const builder = new AssetManifestBuilder();
-    const bodyparam = await makeBodyParameter(forceUploadStack, resolvedEnvironment, builder, toolkitInfo, sdk, overrideTemplate);
+    const bodyparam = await makeBodyParameter(forceUploadStack, resolvedEnvironment, builder, resources, sdk, overrideTemplate);
     const manifest = builder.toManifest(stack.assembly.directory);
     await publishAssets(manifest, sdkProvider, resolvedEnvironment, {
         quiet: true,

package/cdk/deployments-wrapper.js

@@ -3,7 +3,6 @@ import { AssetManifest } from "cdk-assets";
 import { debug } from "sst-aws-cdk/lib/logging.js";
 import { CloudFormationStack, TemplateParameters, waitForStackDelete, } from "sst-aws-cdk/lib/api/util/cloudformation.js";
 import { Mode } from "sst-aws-cdk/lib/api/aws-auth/credentials.js";
-import { ToolkitInfo } from "sst-aws-cdk/lib/api/toolkit-info.js";
 import { addMetadataAssetsToManifest } from "sst-aws-cdk/lib/assets.js";
 import { publishAssets } from "sst-aws-cdk/lib/util/asset-publishing.js";
 import { AssetManifestBuilder } from "sst-aws-cdk/lib/util/asset-manifest-builder.js";
@@ -11,7 +10,7 @@ import { Deployments, } from "./deployments.js";
 import { makeBodyParameter } from "./deploy-stack.js";
 import { lazy } from "../util/lazy.js";
 export async function publishDeployAssets(sdkProvider, options) {
-    const { deployment, toolkitInfo, stackSdk, resolvedEnvironment, cloudFormationRoleArn, } = await useDeployment().get(sdkProvider, options);
+    const { deployment, envResources, stackSdk, resolvedEnvironment, cloudFormationRoleArn, } = await useDeployment().get(sdkProvider, options);
     // TODO
     // old
     //await deployment.publishStackAssets(options.stack, toolkitInfo, {
@@ -44,7 +43,7 @@ export async function publishDeployAssets(sdkProvider, options) {
         sdkProvider,
         roleArn: cloudFormationRoleArn,
         reuseAssets: options.reuseAssets,
-        toolkitInfo,
+        envResources,
         tags: options.tags,
         deploymentMethod: options.deploymentMethod,
         force: options.force,
@@ -67,13 +66,12 @@ const useDeployment = lazy(() => {
             const region = options.stack.environment.region;
             if (!state.has(region)) {
                 const deployment = new Deployments({ sdkProvider });
-                const { stackSdk, resolvedEnvironment, cloudFormationRoleArn } = await deployment.prepareSdkFor(options.stack, options.roleArn, Mode.ForWriting);
-                const toolkitInfo = await ToolkitInfo.lookup(resolvedEnvironment, stackSdk, options.toolkitStackName);
+                const { stackSdk, resolvedEnvironment, cloudFormationRoleArn, envResources, } = await deployment.prepareSdkFor(options.stack, options.roleArn, Mode.ForWriting);
                 // Do a verification of the bootstrap stack version
-                await deployment.validateBootstrapStackVersion(options.stack.stackName, options.stack.requiresBootstrapStackVersion, options.stack.bootstrapStackVersionSsmParameter, toolkitInfo);
+                await deployment.validateBootstrapStackVersion(options.stack.stackName, options.stack.requiresBootstrapStackVersion, options.stack.bootstrapStackVersionSsmParameter, envResources);
                 state.set(region, {
                     deployment,
-                    toolkitInfo,
+                    envResources,
                     stackSdk,
                     resolvedEnvironment,
                     cloudFormationRoleArn,
@@ -106,13 +104,13 @@ async function deployStack(options) {
     // an ad-hoc asset manifest, while passing their locations via template
     // parameters.
     const legacyAssets = new AssetManifestBuilder();
-    const assetParams = await addMetadataAssetsToManifest(stackArtifact, legacyAssets, options.toolkitInfo, options.reuseAssets);
+    const assetParams = await addMetadataAssetsToManifest(stackArtifact, legacyAssets, options.envResources, options.reuseAssets);
     const finalParameterValues = { ...options.parameters, ...assetParams };
     const templateParams = TemplateParameters.fromTemplate(stackArtifact.template);
     const stackParams = options.usePreviousParameters
         ? templateParams.updateExisting(finalParameterValues, cloudFormationStack.parameters)
         : templateParams.supplyAll(finalParameterValues);
-    const bodyParameter = await makeBodyParameter(stackArtifact, options.resolvedEnvironment, legacyAssets, options.toolkitInfo, options.sdk, options.overrideTemplate);
+    const bodyParameter = await makeBodyParameter(stackArtifact, options.resolvedEnvironment, legacyAssets, options.envResources, options.sdk, options.overrideTemplate);
     await publishAssets(legacyAssets.toManifest(stackArtifact.assembly.directory), options.sdkProvider, stackEnv, {
         parallel: options.assetParallelism,
     });

package/cdk/deployments.d.ts

@@ -6,7 +6,7 @@ import { Mode } from "sst-aws-cdk/lib/api/aws-auth/credentials.js";
 import { ISDK } from "sst-aws-cdk/lib/api/aws-auth/sdk.js";
 import { SdkProvider } from "sst-aws-cdk/lib/api/aws-auth/sdk-provider.js";
 import { DeployStackResult, DeploymentMethod } from "./deploy-stack.js";
-import { ToolkitInfo } from "sst-aws-cdk/lib/api/toolkit-info.js";
+import { EnvironmentResources } from "sst-aws-cdk/lib/api/environment-resources.js";
 import { Template, ResourcesToImport, ResourceIdentifierSummaries } from "sst-aws-cdk/lib/api/util/cloudformation.js";
 import { StackActivityProgress } from "sst-aws-cdk/lib/api/util/cloudformation/stack-activity-monitor.js";
 import { HotswapMode } from "sst-aws-cdk/lib/api/hotswap/common.js";
@@ -31,6 +31,10 @@ export interface PreparedSdkWithLookupRoleForEnvironment {
      * the default credentials (not the assume role credentials)
      */
     readonly didAssumeRole: boolean;
+    /**
+     * An object for accessing the bootstrap resources in this environment
+     */
+    readonly envResources: EnvironmentResources;
 }
 export interface DeployStackOptions {
     /**
@@ -212,6 +216,7 @@ export interface StackExistsOptions {
 }
 export interface DeploymentsProps {
     sdkProvider: SdkProvider;
+    readonly toolkitStackName?: string;
     readonly quiet?: boolean;
 }
 /**
@@ -234,6 +239,10 @@ export interface PreparedSdkForEnvironment {
      * @default - no execution role is used
      */
     readonly cloudFormationRoleArn?: string;
+    /**
+     * Access class for environmental resources to help the deployment
+     */
+    readonly envResources: EnvironmentResources;
 }
 /**
  * Scope for a single set of deployments from a set of Cloud Assembly Artifacts
@@ -243,13 +252,13 @@ export interface PreparedSdkForEnvironment {
 export declare class Deployments {
     private readonly props;
     private readonly sdkProvider;
-    private readonly toolkitInfoCache;
     private readonly sdkCache;
     private readonly publisherCache;
+    private readonly environmentResources;
     constructor(props: DeploymentsProps);
     readCurrentTemplateWithNestedStacks(rootStackArtifact: cxapi.CloudFormationStackArtifact, retrieveProcessedTemplate?: boolean): Promise<Template>;
     readCurrentTemplate(stackArtifact: cxapi.CloudFormationStackArtifact): Promise<Template>;
-    resourceIdentifierSummaries(stackArtifact: cxapi.CloudFormationStackArtifact, toolkitStackName?: string): Promise<ResourceIdentifierSummaries>;
+    resourceIdentifierSummaries(stackArtifact: cxapi.CloudFormationStackArtifact): Promise<ResourceIdentifierSummaries>;
     deployStack(options: DeployStackOptions): Promise<DeployStackResult | undefined>;
     destroyStack(options: DestroyStackOptions): Promise<void>;
     stackExists(options: StackExistsOptions): Promise<boolean>;
@@ -283,10 +292,6 @@ export declare class Deployments {
      * function can then decide to use them or fallback to another role.
      */
     prepareSdkWithLookupRoleFor(stack: cxapi.CloudFormationStackArtifact): Promise<PreparedSdkWithLookupRoleForEnvironment>;
-    /**
-     * Look up the toolkit for a given environment, using a given SDK
-     */
-    lookupToolkit(resolvedEnvironment: cxapi.Environment, sdk: ISDK, toolkitStackName?: string): Promise<ToolkitInfo>;
     private prepareAndValidateAssets;
     /**
      * Build all assets in a manifest
@@ -314,8 +319,10 @@ export declare class Deployments {
     isSingleAssetPublished(assetManifest: AssetManifest, asset: IManifestEntry, options: PublishStackAssetsOptions): Promise<boolean>;
     /**
      * Validate that the bootstrap stack has the right version for this stack
+     *
+     * Call into envResources.validateVersion, but prepend the stack name in case of failure.
      */
-    validateBootstrapStackVersion(stackName: string, requiresBootstrapStackVersion: number | undefined, bootstrapStackVersionSsmParameter: string | undefined, toolkitInfo: ToolkitInfo): Promise<void>;
+    validateBootstrapStackVersion(stackName: string, requiresBootstrapStackVersion: number | undefined, bootstrapStackVersionSsmParameter: string | undefined, envResources: EnvironmentResources): Promise<void>;
     private cachedSdkForEnvironment;
     private cachedPublisher;
 }

package/cdk/deployments.js

@@ -6,11 +6,10 @@ import { debug, warning } from "sst-aws-cdk/lib/logging.js";
 import { buildAssets, publishAssets, PublishingAws, EVENT_TO_LOGGER, } from "sst-aws-cdk/lib/util/asset-publishing.js";
 import { Mode } from "sst-aws-cdk/lib/api/aws-auth/credentials.js";
 import { deployStack, destroyStack, makeBodyParameterAndUpload, } from "./deploy-stack.js";
-import { loadCurrentTemplateWithNestedStacks, loadCurrentTemplate, } from "sst-aws-cdk/lib/api/nested-stack-helpers.js";
-import { ToolkitInfo } from "sst-aws-cdk/lib/api/toolkit-info.js";
+import { EnvironmentResourcesRegistry, } from "sst-aws-cdk/lib/api/environment-resources.js";
+import { loadCurrentTemplateWithNestedStacks, loadCurrentTemplate, flattenNestedStackNames, } from "sst-aws-cdk/lib/api/nested-stack-helpers.js";
 import { CloudFormationStack, } from "sst-aws-cdk/lib/api/util/cloudformation.js";
 import { replaceEnvPlaceholders } from "sst-aws-cdk/lib/api/util/placeholders.js";
-import { callWithRetry } from "./util.js";
 /**
  * Scope for a single set of deployments from a set of Cloud Assembly Artifacts
  *
@@ -19,17 +18,22 @@ import { callWithRetry } from "./util.js";
 export class Deployments {
     props;
     sdkProvider;
-    toolkitInfoCache = new Map();
     sdkCache = new Map();
     publisherCache = new Map();
+    environmentResources;
     constructor(props) {
         this.props = props;
         this.sdkProvider = props.sdkProvider;
+        this.environmentResources = new EnvironmentResourcesRegistry(props.toolkitStackName);
     }
     async readCurrentTemplateWithNestedStacks(rootStackArtifact, retrieveProcessedTemplate = false) {
         const sdk = (await this.prepareSdkWithLookupOrDeployRole(rootStackArtifact))
             .stackSdk;
-        return (await loadCurrentTemplateWithNestedStacks(rootStackArtifact, sdk, retrieveProcessedTemplate)).deployedTemplate;
+        const templateWithNestedStacks = await loadCurrentTemplateWithNestedStacks(rootStackArtifact, sdk, retrieveProcessedTemplate);
+        return {
+            deployedTemplate: templateWithNestedStacks.deployedTemplate,
+            nestedStackCount: flattenNestedStackNames(templateWithNestedStacks.nestedStackNames).length,
+        };
     }
     async readCurrentTemplate(stackArtifact) {
         debug(`Reading existing template for stack ${stackArtifact.displayName}.`);
@@ -37,15 +41,14 @@ export class Deployments {
             .stackSdk;
         return loadCurrentTemplate(stackArtifact, sdk);
     }
-    async resourceIdentifierSummaries(stackArtifact, toolkitStackName) {
+    async resourceIdentifierSummaries(stackArtifact) {
         debug(`Retrieving template summary for stack ${stackArtifact.displayName}.`);
         // Currently, needs to use `deploy-role` since it may need to read templates in the staging
         // bucket which have been encrypted with a KMS key (and lookup-role may not read encrypted things)
-        const { stackSdk, resolvedEnvironment } = await this.prepareSdkFor(stackArtifact, undefined, Mode.ForReading);
+        const { stackSdk, resolvedEnvironment, envResources } = await this.prepareSdkFor(stackArtifact, undefined, Mode.ForReading);
         const cfn = stackSdk.cloudFormation();
-        const toolkitInfo = await this.lookupToolkit(resolvedEnvironment, stackSdk, toolkitStackName);
         // Upload the template, if necessary, before passing it to CFN
-        const cfnParam = await makeBodyParameterAndUpload(stackArtifact, resolvedEnvironment, toolkitInfo, this.sdkProvider, stackSdk);
+        const cfnParam = await makeBodyParameterAndUpload(stackArtifact, resolvedEnvironment, envResources, this.sdkProvider, stackSdk);
         const response = await cfn.getTemplateSummary(cfnParam).promise();
         if (!response.ResourceIdentifierSummaries) {
             debug('GetTemplateSummary API call did not return "ResourceIdentifierSummaries"');
@@ -64,10 +67,9 @@ export class Deployments {
                 execute: options.execute,
             };
         }
-        const { stackSdk, resolvedEnvironment, cloudFormationRoleArn } = await this.prepareSdkFor(options.stack, options.roleArn, Mode.ForWriting);
-        const toolkitInfo = await callWithRetry(() => this.lookupToolkit(resolvedEnvironment, stackSdk, options.toolkitStackName));
+        const { stackSdk, resolvedEnvironment, cloudFormationRoleArn, envResources, } = await this.prepareSdkFor(options.stack, options.roleArn, Mode.ForWriting);
         // Do a verification of the bootstrap stack version
-        await this.validateBootstrapStackVersion(options.stack.stackName, options.stack.requiresBootstrapStackVersion, options.stack.bootstrapStackVersionSsmParameter, toolkitInfo);
+        await this.validateBootstrapStackVersion(options.stack.stackName, options.stack.requiresBootstrapStackVersion, options.stack.bootstrapStackVersionSsmParameter, envResources);
         // Deploy assets
         const assetArtifacts = options.stack.dependencies.filter(cxapi.AssetManifestArtifact.isAssetManifestArtifact);
         for (const asset of assetArtifacts) {
@@ -89,7 +91,7 @@ export class Deployments {
             sdkProvider: this.sdkProvider,
             roleArn: cloudFormationRoleArn,
             reuseAssets: options.reuseAssets,
-            toolkitInfo,
+            envResources,
             tags: options.tags,
             deploymentMethod,
             force: options.force,
@@ -129,6 +131,7 @@ export class Deployments {
                 return {
                     resolvedEnvironment: result.resolvedEnvironment,
                     stackSdk: result.sdk,
+                    envResources: result.envResources,
                 };
             }
         }
@@ -164,6 +167,7 @@ export class Deployments {
             stackSdk: stackSdk.sdk,
             resolvedEnvironment,
             cloudFormationRoleArn: arns.cloudFormationRoleArn,
+            envResources: this.environmentResources.for(resolvedEnvironment, stackSdk.sdk),
         };
     }
     /**
@@ -198,11 +202,12 @@ export class Deployments {
                 assumeRoleArn: arns.lookupRoleArn,
                 assumeRoleExternalId: stack.lookupRole?.assumeRoleExternalId,
             });
+            const envResources = this.environmentResources.for(resolvedEnvironment, stackSdk.sdk);
             // if we succeed in assuming the lookup role, make sure we have the correct bootstrap stack version
             if (stackSdk.didAssumeRole &&
                 stack.lookupRole?.bootstrapStackVersionSsmParameter &&
                 stack.lookupRole.requiresBootstrapStackVersion) {
-                const version = await ToolkitInfo.versionFromSsmParameter(stackSdk.sdk, stack.lookupRole.bootstrapStackVersionSsmParameter);
+                const version = await envResources.versionFromSsmParameter(stack.lookupRole.bootstrapStackVersionSsmParameter);
                 if (version < stack.lookupRole.requiresBootstrapStackVersion) {
                     throw new Error(`Bootstrap stack version '${stack.lookupRole.requiresBootstrapStackVersion}' is required, found version '${version}'.`);
                 }
@@ -213,7 +218,7 @@ export class Deployments {
                 stack.lookupRole?.requiresBootstrapStackVersion) {
                 warning(upgradeMessage);
             }
-            return { ...stackSdk, resolvedEnvironment };
+            return { ...stackSdk, resolvedEnvironment, envResources };
         }
         catch (e) {
             debug(e);
@@ -226,26 +231,11 @@ export class Deployments {
             throw e;
         }
     }
-    /**
-     * Look up the toolkit for a given environment, using a given SDK
-     */
-    async lookupToolkit(resolvedEnvironment, sdk, toolkitStackName) {
-        const key = `${resolvedEnvironment.account}:${resolvedEnvironment.region}:${toolkitStackName}`;
-        const existing = this.toolkitInfoCache.get(key);
-        if (existing) {
-            return existing;
-        }
-        const ret = await ToolkitInfo.lookup(resolvedEnvironment, sdk, toolkitStackName);
-        this.toolkitInfoCache.set(key, ret);
-        return ret;
-    }
     async prepareAndValidateAssets(asset, options) {
-        const { stackSdk, resolvedEnvironment } = await this.prepareSdkFor(options.stack, options.roleArn, Mode.ForWriting);
-        const toolkitInfo = await this.lookupToolkit(resolvedEnvironment, stackSdk, options.toolkitStackName);
-        const stackEnv = await this.sdkProvider.resolveEnvironment(options.stack.environment);
-        await this.validateBootstrapStackVersion(options.stack.stackName, asset.requiresBootstrapStackVersion, asset.bootstrapStackVersionSsmParameter, toolkitInfo);
+        const { envResources } = await this.prepareSdkFor(options.stack, options.roleArn, Mode.ForWriting);
+        await this.validateBootstrapStackVersion(options.stack.stackName, asset.requiresBootstrapStackVersion, asset.bootstrapStackVersionSsmParameter, envResources);
         const manifest = AssetManifest.fromFile(asset.file);
-        return { manifest, stackEnv };
+        return { manifest, stackEnv: envResources.environment };
     }
     /**
      * Build all assets in a manifest
@@ -270,10 +260,9 @@ export class Deployments {
      */
     // eslint-disable-next-line max-len
     async buildSingleAsset(assetArtifact, assetManifest, asset, options) {
-        const { stackSdk, resolvedEnvironment: stackEnv } = await this.prepareSdkFor(options.stack, options.roleArn, Mode.ForWriting);
-        const toolkitInfo = await this.lookupToolkit(stackEnv, stackSdk, options.toolkitStackName);
-        await this.validateBootstrapStackVersion(options.stack.stackName, assetArtifact.requiresBootstrapStackVersion, assetArtifact.bootstrapStackVersionSsmParameter, toolkitInfo);
-        const publisher = this.cachedPublisher(assetManifest, stackEnv, options.stackName);
+        const { resolvedEnvironment, envResources } = await this.prepareSdkFor(options.stack, options.roleArn, Mode.ForWriting);
+        await this.validateBootstrapStackVersion(options.stack.stackName, assetArtifact.requiresBootstrapStackVersion, assetArtifact.bootstrapStackVersionSsmParameter, envResources);
+        const publisher = this.cachedPublisher(assetManifest, resolvedEnvironment, options.stackName);
         await publisher.buildEntry(asset);
     }
     /**
@@ -296,13 +285,12 @@ export class Deployments {
     }
     /**
      * Validate that the bootstrap stack has the right version for this stack
+     *
+     * Call into envResources.validateVersion, but prepend the stack name in case of failure.
      */
-    async validateBootstrapStackVersion(stackName, requiresBootstrapStackVersion, bootstrapStackVersionSsmParameter, toolkitInfo) {
-        if (requiresBootstrapStackVersion === undefined) {
-            return;
-        }
+    async validateBootstrapStackVersion(stackName, requiresBootstrapStackVersion, bootstrapStackVersionSsmParameter, envResources) {
         try {
-            await toolkitInfo.validateVersion(requiresBootstrapStackVersion, bootstrapStackVersionSsmParameter);
+            await envResources.validateVersion(requiresBootstrapStackVersion, bootstrapStackVersionSsmParameter);
         }
         catch (e) {
             throw new Error(`${stackName}: ${e.message}`);

package/cli/commands/bind.js

@@ -81,13 +81,10 @@ export const bind = (program) => program
         });
         async function buildApp() {
             const [_metafile, sstConfig] = await Stacks.load(project.paths.config);
-            const cwd = process.cwd();
-            process.chdir(project.paths.root);
             await Stacks.synth({
                 fn: sstConfig.stacks,
                 mode: "remove",
             });
-            process.chdir(cwd);
         }
         function isInSsrSite() {
             const cwd = process.cwd();

package/cli/commands/types.js

@@ -8,10 +8,20 @@ export const types = (program) => program.command("types", "Generate resource ty
     try {
         const project = useProject();
         const [_metafile, sstConfig] = await Stacks.load(project.paths.config);
-        await Stacks.synth({
-            fn: sstConfig.stacks,
+        // Note: do not run synth which requires AWS credentials. B/c generating
+        //       types is usually done inside CI pipelines. And credentials
+        //       might not be available. ie.
+        //  await Stacks.synth({
+        //    fn: sstConfig.stacks,
+        //    mode: "remove",
+        //  });
+        const app = new App({
             mode: "remove",
+            stage: project.config.stage,
+            name: project.config.name,
+            region: project.config.region,
         });
+        sstConfig.stacks(app);
         Colors.line(Colors.success(`✔ `), `Types generated in ${path.resolve(project.paths.out, "types")}`);
         await exit();
     }

package/cli/sst.js

@@ -3,7 +3,6 @@ import { blue, red } from "colorette";
 import { program } from "./program.js";
 import { SilentError, VisibleError } from "../error.js";
 import { useSpinners } from "./spinner.js";
-import { Logger } from "../logger.js";
 import dotenv from "dotenv";
 dotenv.config({
     override: true,
@@ -48,7 +47,6 @@ if ("setSourceMapsEnabled" in process) {
 }
 process.removeAllListeners("uncaughtException");
 process.on("uncaughtException", (err) => {
-    Logger.debug(err);
     const spinners = useSpinners();
     for (const spinner of spinners) {
         if (spinner.isSpinning)

package/constructs/BaseSite.d.ts

@@ -1,9 +1,18 @@
 import { ErrorResponse, DistributionProps, BehaviorOptions, IOrigin } from "aws-cdk-lib/aws-cloudfront";
 export interface BaseSiteFileOptions {
-    exclude: string | string[];
-    include: string | string[];
-    cacheControl: string;
+    filters: {
+        [key in "include" | "exclude"]?: string;
+    }[];
+    cacheControl?: string;
     contentType?: string;
+    contentEncoding?: string;
+}
+export interface BaseSiteFileOptionsDeprecated {
+    include?: string | string[];
+    exclude?: string | string[];
+    cacheControl?: string;
+    contentType?: string;
+    contentEncoding?: string;
 }
 export interface BaseSiteEnvironmentOutputsInfo {
     path: string;

package/constructs/Distribution.d.ts

@@ -132,7 +132,7 @@ export declare class Distribution extends Construct {
         hostedZone: IHostedZone | undefined;
         certificate: ICertificate | undefined;
     };
-    createInvalidation(buildId?: string): CustomResource;
+    createInvalidation(buildId?: string, paths?: string[]): CustomResource;
     private validateCloudFrontDistributionSettings;
     private validateCustomDomainSettings;
     private lookupHostedZone;

package/constructs/Distribution.js

@@ -70,7 +70,7 @@ export class Distribution extends Construct {
             certificate: this.certificate,
         };
     }
-    createInvalidation(buildId) {
+    createInvalidation(buildId, paths) {
         const stack = Stack.of(this);
         const policy = new Policy(this.scope, "CloudFrontInvalidatorPolicy", {
             statements: [
@@ -93,7 +93,7 @@ export class Distribution extends Construct {
             properties: {
                 buildId: buildId || Date.now().toString(),
                 distributionId: this.distribution.distributionId,
-                paths: ["/*"],
+                paths: paths ?? ["/*"],
                 waitForInvalidation: this.props.waitForInvalidation,
             },
         });

package/constructs/NextjsSite.d.ts

@@ -3,6 +3,7 @@ import { Runtime, FunctionProps, Architecture } from "aws-cdk-lib/aws-lambda";
 import { SsrSite, SsrSiteNormalizedProps, SsrSiteProps } from "./SsrSite.js";
 import { Size } from "./util/size.js";
 import { Bucket } from "aws-cdk-lib/aws-s3";
+import { CachePolicyProps } from "aws-cdk-lib/aws-cloudfront";
 export interface NextjsSiteProps extends Omit<SsrSiteProps, "nodejs"> {
     imageOptimization?: {
         /**
@@ -101,6 +102,7 @@ export declare class NextjsSite extends SsrSite {
     props: NextjsSiteNormalizedProps;
     private buildId?;
     constructor(scope: Construct, id: string, props?: NextjsSiteProps);
+    static buildDefaultServerCachePolicyProps(): CachePolicyProps;
     protected plan(bucket: Bucket): {
         cloudFrontFunctions?: {
             serverCfFunction: {

package/constructs/NextjsSite.js

@@ -12,6 +12,13 @@ import { toCdkSize } from "./util/size.js";
 import { PolicyStatement } from "aws-cdk-lib/aws-iam";
 import { RetentionDays } from "aws-cdk-lib/aws-logs";
 import { VisibleError } from "../error.js";
+const DEFAULT_CACHE_POLICY_ALLOWED_HEADERS = [
+    "accept",
+    "rsc",
+    "next-router-prefetch",
+    "next-router-state-tree",
+    "next-url",
+];
 /**
  * The `NextjsSite` construct is a higher level CDK construct that makes it easy to create a Next.js app.
  * @example
@@ -52,6 +59,9 @@ export class NextjsSite extends SsrSite {
             }
         }
     }
+    static buildDefaultServerCachePolicyProps() {
+        return super.buildDefaultServerCachePolicyProps(DEFAULT_CACHE_POLICY_ALLOWED_HEADERS);
+    }
     plan(bucket) {
         const { path: sitePath, edge, experimental, imageOptimization, } = this.props;
         const serverConfig = {
@@ -184,13 +194,7 @@ export class NextjsSite extends SsrSite {
                     origin: "s3",
                 })),
             ],
-            cachePolicyAllowedHeaders: [
-                "accept",
-                "rsc",
-                "next-router-prefetch",
-                "next-router-state-tree",
-                "next-url",
-            ],
+            cachePolicyAllowedHeaders: DEFAULT_CACHE_POLICY_ALLOWED_HEADERS,
             buildId: this.getBuildId(),
             warmerConfig: {
                 function: path.join(sitePath, ".open-next", "warmer-function"),
@@ -287,15 +291,22 @@ export class NextjsSite extends SsrSite {
         };
     }
     wrapHandler() {
-        const { path: sitePath } = this.props;
+        const { path: sitePath, experimental } = this.props;
         const wrapperName = "nextjssite-index";
         const serverPath = path.join(sitePath, ".open-next", "server-function");
-        fs.writeFileSync(path.join(serverPath, `${wrapperName}.mjs`), [
-            `import { handler as rawHandler } from "./index.mjs";`,
-            `export const handler = (event, context) => {`,
-            `  return rawHandler(event, context);`,
-            `};`,
-        ].join("\n"));
+        fs.writeFileSync(path.join(serverPath, `${wrapperName}.mjs`), experimental?.streaming
+            ? [
+                `export const handler = awslambda.streamifyResponse(async (...args) => {`,
+                `  const { handler: rawHandler} = await import("./index.mjs");`,
+                `  return rawHandler(...args);`,
+                `});`,
+            ].join("\n")
+            : [
+                `export const handler = async (...args) => {`,
+                `  const { handler: rawHandler} = await import("./index.mjs");`,
+                `  return rawHandler(...args);`,
+                `};`,
+            ].join("\n"));
         return `${wrapperName}.handler`;
     }
     getRoutes() {

package/constructs/Script.d.ts

@@ -51,8 +51,7 @@ export interface ScriptProps {
         function?: FunctionProps;
     };
     /**
-     * Creates the function that runs when the Script is created.
-     *
+     * Specifies the function to be run once when the Script construct is created.
      * @example
      * ```js
      * new Script(stack, "Api", {
@@ -62,8 +61,11 @@ export interface ScriptProps {
      */
     onCreate?: FunctionDefinition;
     /**
-     * Creates the function that runs on every deploy after the Script is created
+     * Specifies the function to be run each time the Script construct is redeployed. If a version is provided,
+     * the function is only executed when the version changes.
      *
+     * Note that the `onUpdate` function is not run during the initial creation of the Script construct.
+     * For initial creation, use `onCreate`.
      * @example
      * ```js
      * new Script(stack, "Api", {
@@ -73,8 +75,8 @@ export interface ScriptProps {
      */
     onUpdate?: FunctionDefinition;
     /**
-     * Create the function that runs when the Script is deleted from the stack.
-     *
+     * Specifies the function to be run once when the Script construct is deleted from the stack or
+     * when the entire stack is removed from the app.
      * @example
      * ```js
      * new Script(stack, "Api", {