sst 2.27.0 → 2.28.0

package/constructs/AstroSite.js

@@ -1,8 +1,8 @@
 import { readFileSync, existsSync, readdirSync, statSync } from "fs";
 import { join } from "path";
-import { BUILD_META_FILE_NAME } from "astro-sst/build-meta";
 import { SsrSite, } from "./SsrSite.js";
 import { AllowedMethods } from "aws-cdk-lib/aws-cloudfront";
+const BUILD_META_FILE_NAME = "sst.buildMeta.json";
 /**
  * The `AstroSite` construct is a higher level CDK construct that makes it easy to create a Astro app.
  * @example

package/constructs/NextjsSite.d.ts

@@ -10,11 +10,49 @@ export interface NextjsSiteProps extends Omit<SsrSiteProps, "nodejs"> {
          * @default 1024 MB
          * @example
          * ```js
-         * memorySize: "512 MB",
+         * imageOptimization: {
+         *   memorySize: "512 MB",
+         * }
          * ```
          */
         memorySize?: number | Size;
     };
+    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.
+         * @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,
+         * }
+         * ```
+         */
+        disableDynamoDBCache?: boolean;
+    };
     cdk?: SsrSiteProps["cdk"] & {
         revalidation?: Pick<FunctionProps, "vpc" | "vpcSubnets">;
         /**
@@ -129,6 +167,7 @@ export declare class NextjsSite extends SsrSite {
                         CACHE_BUCKET_REGION: string;
                     };
                 };
+                streaming: boolean | undefined;
             } | undefined;
         };
         behaviors: {
@@ -147,7 +186,8 @@ export declare class NextjsSite extends SsrSite {
             schedule?: import("aws-cdk-lib/aws-events").Schedule | undefined;
         } | undefined;
     };
-    protected createRevalidation(): void;
+    private createRevalidationQueue;
+    private createRevalidationTable;
     getConstructMetadata(): {
         data: {
             mode: "placeholder" | "deployed";

package/constructs/NextjsSite.js

@@ -1,12 +1,16 @@
 import fs from "fs";
 import path from "path";
-import { Duration as CdkDuration } from "aws-cdk-lib/core";
+import { Duration as CdkDuration, RemovalPolicy, CustomResource, } from "aws-cdk-lib/core";
 import { Code, Runtime, Function as CdkFunction, Architecture, } from "aws-cdk-lib/aws-lambda";
+import { AttributeType, Billing, TableV2 as Table, } from "aws-cdk-lib/aws-dynamodb";
+import { Provider } from "aws-cdk-lib/custom-resources";
 import { Queue } from "aws-cdk-lib/aws-sqs";
 import { SqsEventSource } from "aws-cdk-lib/aws-lambda-event-sources";
 import { Stack } from "./Stack.js";
 import { SsrSite } from "./SsrSite.js";
 import { toCdkSize } from "./util/size.js";
+import { PolicyStatement } from "aws-cdk-lib/aws-iam";
+import { RetentionDays } from "aws-cdk-lib/aws-logs";
 /**
  * The `NextjsSite` construct is a higher level CDK construct that makes it easy to create a Next.js app.
  * @example
@@ -20,14 +24,34 @@ import { toCdkSize } from "./util/size.js";
  */
 export class NextjsSite extends SsrSite {
     constructor(scope, id, props) {
+        const { streaming, disableDynamoDBCache, disableIncrementalCache } = {
+            streaming: false,
+            disableDynamoDBCache: false,
+            disableIncrementalCache: false,
+            ...props?.experimental,
+        };
         super(scope, id, {
-            buildCommand: "npx --yes open-next@2.1.5 build",
+            buildCommand: [
+                "npx --yes open-next@2.2.1 build",
+                ...(streaming ? ["--streaming"] : []),
+                ...(disableDynamoDBCache
+                    ? ["--dangerously-disable-dynamodb-cache"]
+                    : []),
+                ...(disableIncrementalCache
+                    ? ["--dangerously-disable-incremental-cache"]
+                    : []),
+            ].join(" "),
             ...props,
         });
-        this.createRevalidation();
+        if (!disableIncrementalCache) {
+            this.createRevalidationQueue();
+            if (!disableDynamoDBCache) {
+                this.createRevalidationTable();
+            }
+        }
     }
     plan(bucket) {
-        const { path: sitePath, edge, imageOptimization } = this.props;
+        const { path: sitePath, edge, experimental, imageOptimization, } = this.props;
         const serverConfig = {
             description: "Next.js server",
             bundle: path.join(sitePath, ".open-next", "server-function"),
@@ -61,6 +85,7 @@ export class NextjsSite extends SsrSite {
                             type: "function",
                             constructId: "ServerFunction",
                             function: serverConfig,
+                            streaming: experimental?.streaming,
                         },
                     }),
                 imageOptimizer: {
@@ -172,10 +197,11 @@ export class NextjsSite extends SsrSite {
             },
         });
     }
-    createRevalidation() {
+    createRevalidationQueue() {
         if (!this.serverFunction)
             return;
         const { cdk } = this.props;
+        const server = this.serverFunction;
         const queue = new Queue(this, "RevalidationQueue", {
             fifo: true,
             receiveMessageWaitTime: CdkDuration.seconds(20),
@@ -190,10 +216,64 @@ export class NextjsSite extends SsrSite {
         });
         consumer.addEventSource(new SqsEventSource(queue, { batchSize: 5 }));
         // Allow server to send messages to the queue
+        server.addEnvironment("REVALIDATION_QUEUE_URL", queue.queueUrl);
+        server.addEnvironment("REVALIDATION_QUEUE_REGION", Stack.of(this).region);
+        queue.grantSendMessages(server.role);
+    }
+    createRevalidationTable() {
+        if (!this.serverFunction)
+            return;
+        const { path: sitePath } = this.props;
         const server = this.serverFunction;
-        server?.addEnvironment("REVALIDATION_QUEUE_URL", queue.queueUrl);
-        server?.addEnvironment("REVALIDATION_QUEUE_REGION", Stack.of(this).region);
-        queue.grantSendMessages(server?.role);
+        const table = new Table(this, "RevalidationTable", {
+            partitionKey: { name: "tag", type: AttributeType.STRING },
+            sortKey: { name: "path", type: AttributeType.STRING },
+            pointInTimeRecovery: true,
+            billing: Billing.onDemand(),
+            globalSecondaryIndexes: [
+                {
+                    indexName: "revalidate",
+                    partitionKey: { name: "path", type: AttributeType.STRING },
+                    sortKey: { name: "revalidatedAt", type: AttributeType.NUMBER },
+                },
+            ],
+            removalPolicy: RemovalPolicy.DESTROY,
+        });
+        server?.addEnvironment("CACHE_DYNAMO_TABLE", table.tableName);
+        table.grantReadWriteData(server.role);
+        const dynamodbProviderPath = path.join(sitePath, ".open-next", "dynamodb-provider");
+        if (fs.existsSync(dynamodbProviderPath)) {
+            const insertFn = new CdkFunction(this, "RevalidationInsertFunction", {
+                description: "Next.js revalidation data insert",
+                handler: "index.handler",
+                code: Code.fromAsset(dynamodbProviderPath),
+                runtime: Runtime.NODEJS_18_X,
+                timeout: CdkDuration.minutes(15),
+                initialPolicy: [
+                    new PolicyStatement({
+                        actions: [
+                            "dynamodb:BatchWriteItem",
+                            "dynamodb:PutItem",
+                            "dynamodb:DescribeTable",
+                        ],
+                        resources: [table.tableArn],
+                    }),
+                ],
+                environment: {
+                    CACHE_DYNAMO_TABLE: table.tableName,
+                },
+            });
+            const provider = new Provider(this, "RevalidationProvider", {
+                onEventHandler: insertFn,
+                logRetention: RetentionDays.ONE_DAY,
+            });
+            new CustomResource(this, "RevalidationResource", {
+                serviceToken: provider.serviceToken,
+                properties: {
+                    version: Date.now().toString(),
+                },
+            });
+        }
     }
     getConstructMetadata() {
         return {

package/constructs/Service.d.ts

@@ -1,4 +1,5 @@
 import { Construct } from "constructs";
+import { DistributionProps } from "aws-cdk-lib/aws-cloudfront";
 import { DistributionDomainProps } from "./Distribution.js";
 import { SSTConstruct } from "./Construct.js";
 import { Permissions } from "./util/permission.js";
@@ -18,6 +19,8 @@ declare const supportedCpus: {
 };
 export interface ServiceDomainProps extends DistributionDomainProps {
 }
+export interface ServiceCdkDistributionProps extends Omit<DistributionProps, "defaultBehavior"> {
+}
 export interface ServiceProps {
     /**
      * Path to the directory where the app is located.
@@ -272,7 +275,7 @@ export interface ServiceProps {
     };
     cdk?: {
         /**
-         * By default, SST creates a CloudFront distribution. Set this to `false` to skip creating the distribution.
+         * By default, SST creates a CloudFront distribution. Pass in a value to override the default settings this construct uses to create the CDK `Distribution` internally. Alternatively, set this to `false` to skip creating the distribution.
          * @default true
          * @example
          * ```js
@@ -283,7 +286,7 @@ export interface ServiceProps {
          * }
          * ```
          */
-        cloudfrontDistribution?: boolean;
+        cloudfrontDistribution?: boolean | ServiceCdkDistributionProps;
         /**
          * By default, SST creates an Application Load Balancer to distribute requests across containers. Set this to `false` to skip creating the load balancer.
          * @default true

package/constructs/Service.js

@@ -517,6 +517,9 @@ export class Service extends Construct {
                         cachePolicy,
                         originRequestPolicy: OriginRequestPolicy.ALL_VIEWER,
                     },
+                    ...(cdk?.cloudfrontDistribution === true
+                        ? {}
+                        : cdk?.cloudfrontDistribution),
                 },
             },
         });

package/package.json

@@ -1,7 +1,7 @@
 {
   "sideEffects": false,
   "name": "sst",
-  "version": "2.27.0",
+  "version": "2.28.0",
   "bin": {
     "sst": "cli/sst.js"
   },
@@ -119,7 +119,7 @@
     "@types/ws": "^8.5.3",
     "@types/yargs": "^17.0.13",
     "archiver": "^5.3.1",
-    "astro-sst": "2.27.0",
+    "astro-sst": "2.28.0",
     "tsx": "^3.12.1",
     "typescript": "^5.2.2",
     "vitest": "^0.33.0"