sst 2.41.5 → 2.43.0

package/cdk/deployments.d.ts

@@ -7,6 +7,7 @@ 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 { EnvironmentResources } from "sst-aws-cdk/lib/api/environment-resources.js";
+import { RootTemplateWithNestedStacks } from "sst-aws-cdk/lib/api/nested-stack-helpers.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";
@@ -219,6 +220,7 @@ export interface DestroyStackOptions {
 export interface StackExistsOptions {
     stack: cxapi.CloudFormationStackArtifact;
     deployName?: string;
+    tryLookupRole?: boolean;
 }
 export interface DeploymentsProps {
     sdkProvider: SdkProvider;
@@ -266,7 +268,7 @@ export declare class Deployments {
      * Resolves the environment for a stack.
      */
     resolveEnvironment(stack: cxapi.CloudFormationStackArtifact): Promise<cxapi.Environment>;
-    readCurrentTemplateWithNestedStacks(rootStackArtifact: cxapi.CloudFormationStackArtifact, retrieveProcessedTemplate?: boolean): Promise<Template>;
+    readCurrentTemplateWithNestedStacks(rootStackArtifact: cxapi.CloudFormationStackArtifact, retrieveProcessedTemplate?: boolean): Promise<RootTemplateWithNestedStacks>;
     readCurrentTemplate(stackArtifact: cxapi.CloudFormationStackArtifact): Promise<Template>;
     resourceIdentifierSummaries(stackArtifact: cxapi.CloudFormationStackArtifact): Promise<ResourceIdentifierSummaries>;
     deployStack(options: DeployStackOptions): Promise<DeployStackResult | undefined>;

package/cdk/deployments.js

@@ -2,12 +2,12 @@
 import * as cxapi from "@aws-cdk/cx-api";
 import * as cdk_assets from "cdk-assets";
 import { AssetManifest } from "cdk-assets";
-import { debug, warning } from "sst-aws-cdk/lib/logging.js";
+import { debug, warning, error } 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, } from "./deploy-stack.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 { loadCurrentTemplateWithNestedStacks, loadCurrentTemplate, } 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 { makeBodyParameterAndUpload } from "sst-aws-cdk/lib/api/util/template-body-parameter.js";
@@ -36,11 +36,7 @@ export class Deployments {
     async readCurrentTemplateWithNestedStacks(rootStackArtifact, retrieveProcessedTemplate = false) {
         const sdk = (await this.prepareSdkWithLookupOrDeployRole(rootStackArtifact))
             .stackSdk;
-        const templateWithNestedStacks = await loadCurrentTemplateWithNestedStacks(rootStackArtifact, sdk, retrieveProcessedTemplate);
-        return {
-            deployedTemplate: templateWithNestedStacks.deployedTemplate,
-            nestedStackCount: flattenNestedStackNames(templateWithNestedStacks.nestedStackNames).length,
-        };
+        return loadCurrentTemplateWithNestedStacks(rootStackArtifact, sdk, retrieveProcessedTemplate);
     }
     async readCurrentTemplate(stackArtifact) {
         debug(`Reading existing template for stack ${stackArtifact.displayName}.`);
@@ -126,7 +122,14 @@ export class Deployments {
         });
     }
     async stackExists(options) {
-        const { stackSdk } = await this.prepareSdkFor(options.stack, undefined, Mode.ForReading);
+        let stackSdk;
+        if (options.tryLookupRole) {
+            stackSdk = (await this.prepareSdkWithLookupOrDeployRole(options.stack))
+                .stackSdk;
+        }
+        else {
+            stackSdk = (await this.prepareSdkFor(options.stack, undefined, Mode.ForReading)).stackSdk;
+        }
         const stack = await CloudFormationStack.lookup(stackSdk.cloudFormation(), options.deployName ?? options.stack.stackName);
         return stack.exists;
     }
@@ -206,8 +209,8 @@ export class Deployments {
         }, resolvedEnvironment, this.sdkProvider);
         // try to assume the lookup role
         const warningMessage = `Could not assume ${arns.lookupRoleArn}, proceeding anyway.`;
-        const upgradeMessage = `(To get rid of this warning, please upgrade to bootstrap version >= ${stack.lookupRole?.requiresBootstrapStackVersion})`;
         try {
+            // Trying to assume lookup role and cache the sdk for the environment
             const stackSdk = await this.cachedSdkForEnvironment(resolvedEnvironment, Mode.ForReading, {
                 assumeRoleArn: arns.lookupRoleArn,
                 assumeRoleExternalId: stack.lookupRole?.assumeRoleExternalId,
@@ -219,24 +222,24 @@ export class Deployments {
                 stack.lookupRole.requiresBootstrapStackVersion) {
                 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}'.`);
+                    throw new Error(`Bootstrap stack version '${stack.lookupRole.requiresBootstrapStackVersion}' is required, found version '${version}'. To get rid of this error, please upgrade to bootstrap version >= ${stack.lookupRole.requiresBootstrapStackVersion}`);
                 }
-                // we may not have assumed the lookup role because one was not provided
-                // if that is the case then don't print the upgrade warning
             }
-            else if (!stackSdk.didAssumeRole &&
-                stack.lookupRole?.requiresBootstrapStackVersion) {
-                warning(upgradeMessage);
+            else if (!stackSdk.didAssumeRole) {
+                const lookUpRoleExists = stack.lookupRole ? true : false;
+                warning(`Lookup role ${lookUpRoleExists ? "exists but" : "does not exist, hence"} was not assumed. Proceeding with default credentials.`);
             }
             return { ...stackSdk, resolvedEnvironment, envResources };
         }
         catch (e) {
             debug(e);
-            // only print out the warnings if the lookupRole exists AND there is a required
-            // bootstrap version, otherwise the warnings will print `undefined`
-            if (stack.lookupRole && stack.lookupRole.requiresBootstrapStackVersion) {
+            // only print out the warnings if the lookupRole exists
+            if (stack.lookupRole) {
                 warning(warningMessage);
-                warning(upgradeMessage);
+            }
+            // This error should be shown even if debug mode is off
+            if (e instanceof Error && e.message.includes("Bootstrap stack version")) {
+                error(e.message);
             }
             throw e;
         }

package/constructs/AstroSite.d.ts

@@ -18,38 +18,9 @@ export declare class AstroSite extends SsrSite {
     private static getBuildMeta;
     private static getCFRoutingFunction;
     protected plan(): {
-        cloudFrontFunctions?: Record<string, {
-            constructId: string;
-            injections: string[];
-        }> | undefined;
-        edgeFunctions?: Record<string, {
-            constructId: string;
-            function: import("./EdgeFunction.js").EdgeFunctionProps;
-        }> | undefined;
-        origins: Record<string, {
-            type: "function";
-            constructId: string;
-            function: import("./SsrFunction.js").SsrFunctionProps;
-            injections?: string[] | undefined;
-            streaming?: boolean | undefined;
-        } | {
-            type: "image-optimization-function";
-            function: import("aws-cdk-lib/aws-lambda").FunctionProps;
-        } | {
-            type: "s3";
-            originPath?: string | undefined;
-            copy: {
-                from: string;
-                to: string;
-                cached: boolean;
-                versionedSubDir?: string | undefined;
-            }[];
-        } | {
-            type: "group";
-            primaryOriginName: string;
-            fallbackOriginName: string;
-            fallbackStatusCodes?: number[] | undefined;
-        }>;
+        cloudFrontFunctions?: Record<string, import("./SsrSite.js").CloudFrontFunctionConfig> | undefined;
+        edgeFunctions?: Record<string, import("./SsrSite.js").EdgeFunctionConfig> | undefined;
+        origins: Record<string, import("./SsrSite.js").FunctionOriginConfig | import("./SsrSite.js").ImageOptimizationFunctionOriginConfig | import("./SsrSite.js").S3OriginConfig | import("./SsrSite.js").OriginGroupConfig>;
         edge: boolean;
         behaviors: {
             cacheType: "server" | "static";
@@ -64,6 +35,9 @@ export declare class AstroSite extends SsrSite {
             allowedHeaders?: string[] | undefined;
         } | undefined;
         buildId?: string | undefined;
+        warmer?: {
+            function: string;
+        } | undefined;
     };
     getConstructMetadata(): {
         data: {

package/constructs/Function.js

@@ -49,8 +49,8 @@ const supportedRuntimes = {
     java11: CDKRuntime.JAVA_11,
     java17: CDKRuntime.JAVA_17,
     java21: CDKRuntime.JAVA_21,
-    "go1.x": CDKRuntime.PROVIDED_AL2,
-    go: CDKRuntime.PROVIDED_AL2,
+    "go1.x": CDKRuntime.PROVIDED_AL2023,
+    go: CDKRuntime.PROVIDED_AL2023,
 };
 /**
  * The `Function` construct is a higher level CDK construct that makes it easy to create a Lambda Function with support for Live Lambda Development.

package/constructs/NextjsSite.d.ts

@@ -1,9 +1,18 @@
 import { Construct } from "constructs";
-import { Runtime, FunctionProps, Architecture } from "aws-cdk-lib/aws-lambda";
-import { SsrSite, SsrSiteNormalizedProps, SsrSiteProps } from "./SsrSite.js";
+import { Runtime, FunctionProps as CdkFunctionProps, Architecture } from "aws-cdk-lib/aws-lambda";
+import { EdgeFunctionConfig, FunctionOriginConfig, 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";
+type OpenNextS3Origin = {
+    type: "s3";
+    originPath: string;
+    copy: {
+        from: string;
+        to: string;
+        cached: boolean;
+        versionedSubDir?: string;
+    }[];
+};
 export interface NextjsSiteProps extends Omit<SsrSiteProps, "nodejs"> {
     /**
      * OpenNext version for building the Next.js site.
@@ -14,17 +23,6 @@ export interface NextjsSiteProps extends Omit<SsrSiteProps, "nodejs"> {
      * ```
      */
     openNextVersion?: string;
-    /**
-     * How the logs are stored in CloudWatch
-     * - "combined" - Logs from all routes are stored in the same log group.
-     * - "per-route" - Logs from each route are stored in a separate log group.
-     * @default "per-route"
-     * @example
-     * ```js
-     * logging: "combined",
-     * ```
-     */
-    logging?: "combined" | "per-route";
     /**
      * The server function is deployed to Lambda in a single region. Alternatively, you can enable this option to deploy to Lambda@Edge.
      * @default false
@@ -42,59 +40,20 @@ export interface NextjsSiteProps extends Omit<SsrSiteProps, "nodejs"> {
          * ```
          */
         memorySize?: number | Size;
-    };
-    openNext?: {
-        /**
-         * Specify a custom build output path for cases when running OpenNext from
-         * a monorepo with decentralized build output. This is passed to the
-         * `--build-output-path` flag of OpenNext.
-         * @default Default build output path
-         * @example
-         * ```js
-         * buildOutputPath: "dist/apps/example-app"
-         * ```
-         */
-        buildOutputPath?: string;
-    };
-    experimental?: {
-        /**
-         * Enable streaming. Currently an experimental feature in OpenNext.
-         * @default false
-         * @example
-         * ```js
-         * experimental: {
-         *   streaming: true,
-         * }
-         * ```
-         */
-        streaming?: boolean;
         /**
-         * Disabling incremental cache will cause the entire page to be revalidated on each request. This can result in ISR and SSG pages to be in an inconsistent state. Specify this option if you are using SSR pages only.
-         *
-         * Note that it is possible to disable incremental cache while leaving on-demand revalidation enabled.
+         * If set to true, already computed image will return 304 Not Modified.
+         * This means that image needs to be immutable, the etag will be computed based on the image href, format and width and the next BUILD_ID.
          * @default false
          * @example
          * ```js
-         * experimental: {
-         *   disableIncrementalCache: true,
-         * }
-         * ```
-         */
-        disableIncrementalCache?: boolean;
-        /**
-         * Disabling DynamoDB cache will cause on-demand revalidation by path (`revalidatePath`) and by cache tag (`revalidateTag`) to fail silently.
-         * @default false
-         * @example
-         * ```js
-         * experimental: {
-         *   disableDynamoDBCache: true,
+         * imageOptimization: {
+         *  staticImageOptimization: true,
          * }
-         * ```
          */
-        disableDynamoDBCache?: boolean;
+        staticImageOptimization?: boolean;
     };
     cdk?: SsrSiteProps["cdk"] & {
-        revalidation?: Pick<FunctionProps, "vpc" | "vpcSubnets">;
+        revalidation?: Pick<CdkFunctionProps, "vpc" | "vpcSubnets">;
         /**
          * Override the CloudFront cache policy properties for responses from the
          * server rendering Lambda.
@@ -145,8 +104,11 @@ export declare class NextjsSite extends SsrSite {
     private appPathsManifest?;
     private pagesManifest?;
     private prerenderManifest?;
-    constructor(scope: Construct, id: string, rawProps?: NextjsSiteProps);
-    static buildDefaultServerCachePolicyProps(): CachePolicyProps;
+    private openNextOutput?;
+    constructor(scope: Construct, id: string, props?: NextjsSiteProps);
+    private createFunctionOrigin;
+    private createEcsOrigin;
+    private createEdgeOrigin;
     protected plan(bucket: Bucket): {
         cloudFrontFunctions?: {
             serverCfFunction: {
@@ -154,26 +116,11 @@ export declare class NextjsSite extends SsrSite {
                 injections: string[];
             };
         } | undefined;
-        edgeFunctions?: {
-            edgeServer: {
-                constructId: string;
-                function: {
-                    description: string;
-                    bundle: string;
-                    handler: string;
-                    environment: {
-                        CACHE_BUCKET_NAME: string;
-                        CACHE_BUCKET_KEY_PREFIX: string;
-                        CACHE_BUCKET_REGION: string;
-                    };
-                    layers: import("aws-cdk-lib/aws-lambda").ILayerVersion[] | undefined;
-                };
-            };
-        } | undefined;
+        edgeFunctions?: Record<string, EdgeFunctionConfig> | undefined;
         origins: {
+            s3: OpenNextS3Origin;
             imageOptimizer: {
                 type: "image-optimization-function";
-                constructId: string;
                 function: {
                     description: string;
                     handler: string;
@@ -181,73 +128,39 @@ export declare class NextjsSite extends SsrSite {
                     runtime: Runtime;
                     architecture: Architecture;
                     environment: {
+                        OPENNEXT_STATIC_ETAG?: string | undefined;
                         BUCKET_NAME: string;
                         BUCKET_KEY_PREFIX: string;
                     };
+                    permissions: string[];
                     memorySize: number;
                 };
             };
-            s3: {
-                type: "s3";
-                originPath: string;
-                copy: ({
-                    from: string;
-                    to: string;
-                    cached: true;
-                    versionedSubDir: string;
-                } | {
-                    from: string;
-                    to: string;
-                    cached: false;
-                    versionedSubDir?: undefined;
-                })[];
-            };
-            regionalServer?: {
-                type: "function";
-                constructId: string;
-                function: {
-                    description: string;
-                    bundle: string;
-                    handler: string;
-                    environment: {
-                        CACHE_BUCKET_NAME: string;
-                        CACHE_BUCKET_KEY_PREFIX: string;
-                        CACHE_BUCKET_REGION: string;
-                    };
-                    layers: import("aws-cdk-lib/aws-lambda").ILayerVersion[] | undefined;
-                };
-                streaming: boolean | undefined;
-                injections: string[];
-            } | undefined;
+            default: FunctionOriginConfig;
         };
         edge: boolean;
         behaviors: {
             cacheType: "server" | "static";
             pattern?: string | undefined;
-            origin: "s3" | "regionalServer" | "imageOptimizer";
+            origin: "default" | "s3" | "imageOptimizer";
             allowedMethods?: import("aws-cdk-lib/aws-cloudfront").AllowedMethods | undefined;
             cfFunction?: "serverCfFunction" | undefined;
-            edgeFunction?: "edgeServer" | undefined;
+            edgeFunction?: string | undefined;
         }[];
         errorResponses?: import("aws-cdk-lib/aws-cloudfront").ErrorResponse[] | undefined;
         serverCachePolicy?: {
             allowedHeaders?: string[] | undefined;
         } | undefined;
         buildId?: string | undefined;
+        warmer?: {
+            function: string;
+        } | undefined;
     };
-    private prefixPattern;
+    private setMiddlewareEnv;
     private createRevalidationQueue;
     private createRevalidationTable;
     getConstructMetadata(): {
-        type: "NextjsSite";
         data: {
-            routes: {
-                logGroupPrefix: string;
-                data: {
-                    route: string;
-                    logGroupPath: string;
-                }[];
-            } | undefined;
             mode: "placeholder" | "deployed";
             path: string;
             runtime: "nodejs16.x" | "nodejs18.x" | "nodejs20.x";
@@ -258,23 +171,20 @@ export declare class NextjsSite extends SsrSite {
             secrets: string[];
             prefetchSecrets: boolean | undefined;
         };
+        type: "NextjsSite";
     };
-    private removeSourcemaps;
     private useRoutes;
     private useRoutesManifest;
     private useAppPathRoutesManifest;
     private useAppPathsManifest;
     private usePagesManifest;
     private usePrerenderManifest;
-    private useServerFunctionPerRouteLoggingInjection;
-    private useCloudFrontFunctionPrerenderBypassHeaderInjection;
+    private useCloudFrontFunctionCacheHeaderKey;
+    private useCloudfrontGeoHeadersInjection;
     private getBuildId;
     private getSourcemapForAppRoute;
     private getSourcemapForPagesRoute;
-    private isPerRouteLoggingEnabled;
     private handleMissingSourcemap;
-    private disableDefaultLogging;
-    private uploadSourcemaps;
     private static buildCloudWatchRouteName;
     private static buildCloudWatchRouteHash;
     static _test: {