sst 2.0.0-rc.8 → 2.0.0

package/constructs/SsrFunction.js

@@ -0,0 +1,113 @@
+import url from "url";
+import path from "path";
+import spawn from "cross-spawn";
+import { Construct } from "constructs";
+import * as iam from "aws-cdk-lib/aws-iam";
+import * as logs from "aws-cdk-lib/aws-logs";
+import * as lambda from "aws-cdk-lib/aws-lambda";
+import * as s3Assets from "aws-cdk-lib/aws-s3-assets";
+import { Duration as CdkDuration, CustomResource } from "aws-cdk-lib";
+import { Stack } from "./Stack.js";
+import { useProject } from "../project.js";
+import { attachPermissionsToRole } from "./util/permission.js";
+import { toCdkSize } from "./util/size.js";
+import { toCdkDuration } from "./util/duration.js";
+const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
+/////////////////////
+// Construct
+/////////////////////
+export class SsrFunction extends Construct {
+    function;
+    props;
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.props = props;
+        const { permissions } = props;
+        this.function = this.createFunction();
+        this.attachPermissions(permissions || []);
+    }
+    attachPermissions(permissions) {
+        attachPermissionsToRole(this.function.role, permissions);
+    }
+    createFunction() {
+        const { timeout, memorySize, handler, bundlePath } = this.props;
+        // Note: cannot point the bundlePath to the `.open-next/server-function`
+        //       b/c the folder contains node_modules. And pnpm node_modules
+        //       contains symlinks. CDK cannot zip symlinks correctly.
+        //       https://github.com/aws/aws-cdk/issues/9251
+        //       We will zip the folder ourselves.
+        const zipOutDir = path.resolve(useProject().paths.artifacts, `Site-${this.node.id}-${this.node.addr}`);
+        const script = path.resolve(__dirname, "../support/ssr-site-function-archiver.mjs");
+        const result = spawn.sync("node", [
+            script,
+            path.join(bundlePath),
+            path.join(zipOutDir, "server-function.zip"),
+        ], { stdio: "inherit" });
+        if (result.status !== 0) {
+            throw new Error(`There was a problem generating the assets package.`);
+        }
+        // Create asset
+        const asset = new s3Assets.Asset(this, "Asset", {
+            path: path.join(zipOutDir, "server-function.zip"),
+        });
+        // Deploy after the code is updated
+        const replacer = this.createLambdaCodeReplacer(asset);
+        const fn = new lambda.Function(this, `ServerFunction`, {
+            ...this.props,
+            handler,
+            logRetention: logs.RetentionDays.THREE_DAYS,
+            code: lambda.Code.fromBucket(asset.bucket, asset.s3ObjectKey),
+            runtime: lambda.Runtime.NODEJS_18_X,
+            architecture: lambda.Architecture.ARM_64,
+            memorySize: typeof memorySize === "string"
+                ? toCdkSize(memorySize).toMebibytes()
+                : memorySize,
+            timeout: typeof timeout === "string"
+                ? toCdkDuration(timeout)
+                : CdkDuration.seconds(timeout),
+        });
+        fn.node.addDependency(replacer);
+        return fn;
+    }
+    createLambdaCodeReplacer(asset) {
+        // Note: Source code for the Lambda functions have "{{ ENV_KEY }}" in them.
+        //       They need to be replaced with real values before the Lambda
+        //       functions get deployed.
+        const stack = Stack.of(this);
+        const resource = new CustomResource(this, "AssetReplacer", {
+            serviceToken: stack.customResourceHandler.functionArn,
+            resourceType: "Custom::AssetReplacer",
+            properties: {
+                bucket: asset.s3BucketName,
+                key: asset.s3ObjectKey,
+                replacements: this.getLambdaContentReplaceValues(),
+            },
+        });
+        stack.customResourceHandler.role?.addToPrincipalPolicy(new iam.PolicyStatement({
+            effect: iam.Effect.ALLOW,
+            actions: ["s3:GetObject", "s3:PutObject"],
+            resources: [`arn:${stack.partition}:s3:::${asset.s3BucketName}/*`],
+        }));
+        return resource;
+    }
+    getLambdaContentReplaceValues() {
+        const replaceValues = [];
+        Object.entries(this.props.environment || {}).forEach(([key, value]) => {
+            const token = `{{ ${key} }}`;
+            replaceValues.push({
+                files: "**/*.js",
+                search: token,
+                replace: value,
+            }, {
+                files: "**/*.cjs",
+                search: token,
+                replace: value,
+            }, {
+                files: "**/*.mjs",
+                search: token,
+                replace: value,
+            });
+        });
+        return replaceValues;
+    }
+}

package/constructs/SsrSite.d.ts

@@ -1,35 +1,46 @@
 import { Construct } from "constructs";
-import * as s3 from "aws-cdk-lib/aws-s3";
-import * as lambda from "aws-cdk-lib/aws-lambda";
-import * as route53 from "aws-cdk-lib/aws-route53";
-import * as cloudfront from "aws-cdk-lib/aws-cloudfront";
-import * as acm from "aws-cdk-lib/aws-certificatemanager";
-import * as origins from "aws-cdk-lib/aws-cloudfront-origins";
+import { Bucket, BucketProps, IBucket } from "aws-cdk-lib/aws-s3";
+import { Function, FunctionProps } from "aws-cdk-lib/aws-lambda";
+import { IHostedZone } from "aws-cdk-lib/aws-route53";
+import { Distribution, ICachePolicy, BehaviorOptions, CachePolicy } from "aws-cdk-lib/aws-cloudfront";
+import { ICertificate } from "aws-cdk-lib/aws-certificatemanager";
+import { S3Origin } from "aws-cdk-lib/aws-cloudfront-origins";
 import { SSTConstruct } from "./Construct.js";
 import { EdgeFunction } from "./EdgeFunction.js";
-import { BaseSiteDomainProps, BaseSiteCdkDistributionProps } from "./BaseSite.js";
+import { BaseSiteDomainProps, BaseSiteReplaceProps, BaseSiteCdkDistributionProps } from "./BaseSite.js";
+import { Size } from "./util/size.js";
+import { Duration } from "./util/duration.js";
 import { Permissions } from "./util/permission.js";
 import { FunctionBindingProps } from "./util/functionBinding.js";
-export declare type SsrBuildConfig = {
+export type SsrBuildConfig = {
     serverBuildOutputFile: string;
     clientBuildOutputDir: string;
     clientBuildVersionedSubDir: string;
-    siteStub: string;
 };
 export interface SsrDomainProps extends BaseSiteDomainProps {
 }
+export interface SsrSiteReplaceProps extends BaseSiteReplaceProps {
+}
 export interface SsrCdkDistributionProps extends BaseSiteCdkDistributionProps {
 }
 export interface SsrSiteProps {
     /**
-     * The SSR function is deployed to Lambda in a single region. Alternatively, you can enable this option to deploy to Lambda@Edge.
-     * @default false
+     * Bind resources for the function
+     *
+     * @example
+     * ```js
+     * new Function(stack, "Function", {
+     *   handler: "src/function.handler",
+     *   bind: [STRIPE_KEY, bucket],
+     * })
+     * ```
      */
-    edge?: boolean;
+    bind?: SSTConstruct[];
     /**
      * Path to the directory where the app is located.
+     * @default "."
      */
-    path: string;
+    path?: string;
     /**
      * The command for building the website
      * @default `npm run build`
@@ -60,6 +71,37 @@ export interface SsrSiteProps {
      * ```
      */
     customDomain?: string | SsrDomainProps;
+    /**
+     * The SSR function is deployed to Lambda in a single region. Alternatively, you can enable this option to deploy to Lambda@Edge.
+     * @default false
+     */
+    edge?: boolean;
+    /**
+     * The execution timeout in seconds for SSR function.
+     * @default 10 seconds
+     * @example
+     * ```js
+     * timeout: "5 seconds",
+     * ```
+     */
+    timeout?: number | Duration;
+    /**
+     * The amount of memory in MB allocated for SSR function.
+     * @default 1024 MB
+     * @example
+     * ```js
+     * memorySize: "512 MB",
+     * ```
+     */
+    memorySize?: number | Size;
+    /**
+     * Attaches the given list of permissions to the SSR function. Configuring this property is equivalent to calling `attachPermissions()` after the site is created.
+     * @example
+     * ```js
+     * permissions: ["ses"]
+     * ```
+     */
+    permissions?: Permissions;
     /**
      * An object with the key being the environment variable name.
      *
@@ -72,26 +114,22 @@ export interface SsrSiteProps {
      * ```
      */
     environment?: Record<string, string>;
-    /**
-     * When running `sst start`, a placeholder site is deployed. This is to ensure
-     * that the site content remains unchanged, and subsequent `sst start` can
-     * start up quickly.
-     *
-     * @example
-     * ```js
-     * disablePlaceholder: true,
-     * ```
-     */
-    disablePlaceholder?: boolean;
-    defaults?: {
-        function?: {
-            timeout?: number;
-            memorySize?: number;
-            permissions?: Permissions;
-        };
+    dev?: {
+        /**
+         * When running `sst dev, site is not deployed. This is to ensure `sst dev` can start up quickly.
+         * @default false
+         * @example
+         * ```js
+         * dev: {
+         *   deploy: true
+         * }
+         * ```
+         */
+        deploy?: boolean;
     };
     /**
      * While deploying, SST waits for the CloudFront cache invalidation process to finish. This ensures that the new content will be served once the deploy command finishes. However, this process can sometimes take more than 5 mins. For non-prod environments it might make sense to pass in `false`. That'll skip waiting for the cache to invalidate and speed up the deploy process.
+     * @default false
      */
     waitForInvalidation?: boolean;
     cdk?: {
@@ -102,25 +140,21 @@ export interface SsrSiteProps {
         /**
          * Allows you to override default settings this construct uses internally to ceate the bucket
          */
-        bucket?: s3.BucketProps | s3.IBucket;
+        bucket?: BucketProps | IBucket;
         /**
          * Pass in a value to override the default settings this construct uses to
          * create the CDK `Distribution` internally.
          */
         distribution?: SsrCdkDistributionProps;
         /**
-         * Override the default CloudFront cache policies created internally.
+         * Override the CloudFront cache policy properties for responses from the
+         * server rendering Lambda.
+         *
+         * @note The default cache policy that is used in the abscene of this property
+         * is one that performs no caching of the server response.
          */
-        cachePolicies?: {
-            /**
-             * Override the CloudFront cache policy properties for responses from the
-             * server rendering Lambda.
-             *
-             * @note The default cache policy that is used in the abscene of this property
-             * is one that performs no caching of the server response.
-             */
-            serverRequests?: cloudfront.ICachePolicy;
-        };
+        serverCachePolicy?: ICachePolicy;
+        server?: Pick<FunctionProps, "vpc" | "vpcSubnets" | "securityGroups" | "allowAllOutbound" | "allowPublicSubnet" | "architecture">;
     };
 }
 /**
@@ -136,72 +170,39 @@ export interface SsrSiteProps {
  */
 export declare class SsrSite extends Construct implements SSTConstruct {
     readonly id: string;
-    /**
-     * Exposes CDK instances created within the construct.
-     */
-    readonly cdk: {
-        /**
-         * The internally created CDK `Function` instance. Not available in the "edge" mode.
-         */
-        function?: lambda.Function;
-        /**
-         * The internally created CDK `Bucket` instance.
-         */
-        bucket: s3.Bucket;
-        /**
-         * The internally created CDK `Distribution` instance.
-         */
-        distribution: cloudfront.Distribution;
-        /**
-         * The Route 53 hosted zone for the custom domain.
-         */
-        hostedZone?: route53.IHostedZone;
-        /**
-         * The AWS Certificate Manager certificate for the custom domain.
-         */
-        certificate?: acm.ICertificate;
+    protected props: Omit<SsrSiteProps, "path"> & {
+        path: string;
+        timeout: number | Duration;
+        memorySize: number | Size;
     };
-    protected props: SsrSiteProps;
-    /**
-     * Determines if a placeholder site should be deployed instead. We will set
-     * this to `true` by default when performing local development, although the
-     * user can choose to override this value.
-     */
-    protected isPlaceholder: boolean;
-    /**
-     * The root SST directory used for builds.
-     */
-    protected sstBuildDir: string;
+    private doNotDeploy;
     protected buildConfig: SsrBuildConfig;
     private serverLambdaForEdge?;
-    protected serverLambdaForRegional?: lambda.Function;
-    private awsCliLayer;
-    constructor(scope: Construct, id: string, props: SsrSiteProps);
+    protected serverLambdaForRegional?: Function;
+    private bucket;
+    private distribution;
+    private hostedZone?;
+    private certificate?;
+    constructor(scope: Construct, id: string, props?: SsrSiteProps);
     /**
      * The CloudFront URL of the website.
      */
-    get url(): string;
+    get url(): string | undefined;
     /**
      * If the custom domain is enabled, this is the URL of the website with the
      * custom domain.
      */
     get customDomainUrl(): string | undefined;
     /**
-     * The ARN of the internally created S3 Bucket.
+     * The internally created CDK resources.
      */
-    get bucketArn(): string;
-    /**
-     * The name of the internally created S3 Bucket.
-     */
-    get bucketName(): string;
-    /**
-     * The ID of the internally created CloudFront Distribution.
-     */
-    get distributionId(): string;
-    /**
-     * The domain name of the internally created CloudFront Distribution.
-     */
-    get distributionDomain(): string;
+    get cdk(): {
+        function: Function | undefined;
+        bucket: Bucket;
+        distribution: Distribution;
+        hostedZone: IHostedZone | undefined;
+        certificate: ICertificate | undefined;
+    };
     /**
      * Attaches the given list of permissions to allow the Astro server side
      * rendering to access other AWS resources.
@@ -216,7 +217,6 @@ export declare class SsrSite extends Construct implements SSTConstruct {
     getConstructMetadata(): {
         type: "SsrSite";
         data: {
-            distributionId: string;
             customDomainUrl: string | undefined;
         };
     };
@@ -226,28 +226,28 @@ export declare class SsrSite extends Construct implements SSTConstruct {
     private buildApp;
     protected validateBuildOutput(): void;
     private runBuild;
-    private createStaticsS3Assets;
-    private createStaticsS3AssetsWithStub;
+    private createS3Assets;
+    private createS3AssetFileOptions;
     private createS3Bucket;
     private createS3Deployment;
-    protected createFunctionForRegional(): lambda.Function;
+    protected createFunctionForRegional(): Function;
     protected createFunctionForEdge(): EdgeFunction;
     private createFunctionPermissionsForRegional;
     private createFunctionPermissionsForEdge;
     private validateCloudFrontDistributionSettings;
-    protected createCloudFrontDistributionForRegional(): cloudfront.Distribution;
+    protected createCloudFrontDistributionForRegional(): Distribution;
     private createCloudFrontDistributionForEdge;
-    protected createCloudFrontDistributionForStub(): cloudfront.Distribution;
     protected buildDistributionDomainNames(): string[];
     private buildDistributionDefaultBehaviorForRegional;
     private buildDistributionDefaultBehaviorForEdge;
-    protected buildDistributionStaticFileBehaviors(origin: origins.S3Origin): Record<string, cloudfront.BehaviorOptions>;
-    protected createCloudFrontServerCachePolicy(): cloudfront.CachePolicy;
+    protected buildDistributionStaticFileBehaviors(origin: S3Origin): Record<string, BehaviorOptions>;
+    protected createCloudFrontServerCachePolicy(): CachePolicy;
     private createCloudFrontInvalidation;
     protected validateCustomDomainSettings(): void;
-    protected lookupHostedZone(): route53.IHostedZone | undefined;
+    protected lookupHostedZone(): IHostedZone | undefined;
     private createCertificate;
     protected createRoute53Records(): void;
+    private getS3ContentReplaceValues;
     private validateSiteExists;
     private registerSiteEnvironment;
     protected generateBuildId(): string;