sst 1.16.0 → 2.0.0-rc.0

package/constructs/NextjsSite.js

@@ -0,0 +1,285 @@
+import fs from "fs";
+import url from "url";
+import path from "path";
+import { buildErrorResponsesForRedirectToIndex } from "./BaseSite.js";
+import { Fn, Duration, RemovalPolicy, } from "aws-cdk-lib";
+import * as logs from "aws-cdk-lib/aws-logs";
+import * as lambda from "aws-cdk-lib/aws-lambda";
+import * as cloudfront from "aws-cdk-lib/aws-cloudfront";
+import * as origins from "aws-cdk-lib/aws-cloudfront-origins";
+import { SsrSite } from "./SsrSite.js";
+import { EdgeFunction } from "./EdgeFunction.js";
+const __dirname = url.fileURLToPath(new URL(".", import.meta.url));
+/**
+ * The `NextjsSite` construct is a higher level CDK construct that makes it easy to create a Next.js app.
+ * @example
+ * Deploys a Next.js app in the `my-next-app` directory.
+ *
+ * ```js
+ * new NextjsSite(stack, "web", {
+ *   path: "my-next-app/",
+ * });
+ * ```
+ */
+export class NextjsSite extends SsrSite {
+    constructor(scope, id, props) {
+        super(scope, id, {
+            buildCommand: "npm_config_yes=true npx open-next@latest build",
+            ...props,
+        });
+    }
+    initBuildConfig() {
+        return {
+            serverBuildOutputFile: ".open-next/server-function/index.mjs",
+            clientBuildOutputDir: ".open-next/assets",
+            clientBuildVersionedSubDir: "_next",
+            siteStub: path.resolve(__dirname, "../support/nextjs-site-html-stub"),
+        };
+    }
+    createFunctionForRegional() {
+        const { defaults, environment } = this.props;
+        let bundlePath, handler;
+        if (this.isPlaceholder) {
+            bundlePath = path.resolve(__dirname, "../support/ssr-site-function-stub");
+            handler = "server.handler";
+        }
+        else {
+            bundlePath = path.join(this.props.path, path.dirname(this.buildConfig.serverBuildOutputFile));
+            handler = "index.handler";
+        }
+        return new lambda.Function(this, `ServerFunction`, {
+            description: "Server handler for Next.js",
+            handler,
+            currentVersionOptions: {
+                removalPolicy: RemovalPolicy.DESTROY,
+            },
+            logRetention: logs.RetentionDays.THREE_DAYS,
+            code: lambda.Code.fromAsset(bundlePath),
+            runtime: lambda.Runtime.NODEJS_18_X,
+            memorySize: defaults?.function?.memorySize || 512,
+            timeout: Duration.seconds(defaults?.function?.timeout || 10),
+            environment,
+        });
+    }
+    createCloudFrontDistributionForRegional() {
+        const { cdk } = this.props;
+        const cfDistributionProps = cdk?.distribution || {};
+        const s3Origin = new origins.S3Origin(this.cdk.bucket);
+        // Create server behavior
+        const { fn: middlewareFn, isMiddlewareEnabled } = this.createMiddlewareEdgeFunctionForRegional();
+        const fnUrl = this.serverLambdaForRegional.addFunctionUrl({
+            authType: lambda.FunctionUrlAuthType.NONE,
+        });
+        const serverBehavior = {
+            viewerProtocolPolicy: cloudfront.ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
+            origin: new origins.HttpOrigin(Fn.parseDomainName(fnUrl.url)),
+            allowedMethods: cloudfront.AllowedMethods.ALLOW_ALL,
+            cachedMethods: cloudfront.CachedMethods.CACHE_GET_HEAD_OPTIONS,
+            compress: true,
+            cachePolicy: cdk?.cachePolicies?.serverRequests ??
+                this.createCloudFrontServerCachePolicy(),
+            edgeLambdas: isMiddlewareEnabled && !this.isPlaceholder
+                ? [{
+                        eventType: cloudfront.LambdaEdgeEventType.VIEWER_REQUEST,
+                        functionVersion: middlewareFn.currentVersion,
+                    }]
+                : undefined,
+        };
+        // Create image optimization behavior
+        const imageFn = this.createImageOptimizationFunctionForRegional();
+        const imageFnUrl = imageFn.addFunctionUrl({
+            authType: lambda.FunctionUrlAuthType.NONE,
+        });
+        const imageBehavior = {
+            viewerProtocolPolicy: cloudfront.ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
+            origin: new origins.HttpOrigin(Fn.parseDomainName(imageFnUrl.url)),
+            allowedMethods: cloudfront.AllowedMethods.ALLOW_ALL,
+            cachedMethods: cloudfront.CachedMethods.CACHE_GET_HEAD_OPTIONS,
+            compress: true,
+            cachePolicy: serverBehavior.cachePolicy,
+        };
+        // Create statics behavior
+        const staticFileBehaviour = {
+            origin: s3Origin,
+            viewerProtocolPolicy: cloudfront.ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
+            allowedMethods: cloudfront.AllowedMethods.ALLOW_GET_HEAD_OPTIONS,
+            cachedMethods: cloudfront.CachedMethods.CACHE_GET_HEAD_OPTIONS,
+            compress: true,
+            cachePolicy: cloudfront.CachePolicy.CACHING_OPTIMIZED,
+        };
+        // Create default behavior
+        // default handler for requests that don't match any other path:
+        //   - try S3 first
+        //   - if 403, fall back to lambda handler (mostly for /)
+        //   - if 404, fall back to lambda handler
+        const fallbackOriginGroup = new origins.OriginGroup({
+            primaryOrigin: serverBehavior.origin,
+            fallbackOrigin: s3Origin,
+            fallbackStatusCodes: [404],
+        });
+        const defaultBehavior = {
+            origin: fallbackOriginGroup,
+            viewerProtocolPolicy: cloudfront.ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
+            compress: true,
+            cachePolicy: serverBehavior.cachePolicy,
+            edgeLambdas: serverBehavior.edgeLambdas,
+        };
+        /**
+         * Next.js requests
+         *
+         * - Public asset
+         *  Use case: When you request an asset in /public
+         *  Request: /myImage.png
+         *  Response cache:
+         *  - Cache-Control: public, max-age=0, must-revalidate
+         *  - x-vercel-cache: MISS (1st request)
+         *  - x-vercel-cache: HIT (2nd request)
+         *
+         * - SSG page
+         *  Use case: When you request an SSG page directly
+         *  Request: /myPage
+         *  Response cache:
+         *  - Cache-Control: public, max-age=0, must-revalidate
+         *  - Content-Encoding: br
+         *  - x-vercel-cache: HIT (2nd request, not set for 1st request)
+         *
+         * - SSR page (directly)
+         *  Use case: When you request an SSR page directly
+         *  Request: /myPage
+         *  Response cache:
+         *  - Cache-Control: private, no-cache, no-store, max-age=0, must-revalidate
+         *  - x-vercel-cache: MISS
+         *
+         * - SSR pages (user transition)
+         *  Use case: When the page uses getServerSideProps(), and you request this page on
+         *            client-side page trasitions. Next.js sends an API request to the server,
+         *            which runs getServerSideProps()
+         *  Request: /_next/data/_-fpIB1rqWyRD-EJO59pO/myPage.json
+         *  Response cache:
+         *  - Cache-Control: private, no-cache, no-store, max-age=0, must-revalidate
+         *  - x-vercel-cache: MISS
+         *
+         * - Image optimization
+         *  Use case: when you request an image
+         *  Request: /_next/image?url=%2F_next%2Fstatic%2Fmedia%2F4600x4600.ce39e3d6.jpg&w=256&q=75
+         *  Response cache:
+         *    - Cache-Control: public, max-age=31536000, immutable
+         *    - x-vercel-cache: HIT
+         *
+         * - API
+         *  Use case: when you request an API endpoint
+         *  Request: /api/hello
+         *  Response cache:
+         *    - Cache-Control: public, max-age=0, must-revalidate
+         *    - x-vercel-cache: MISS
+         */
+        return new cloudfront.Distribution(this, "Distribution", {
+            // these values can be overwritten by cfDistributionProps
+            defaultRootObject: "",
+            // Override props.
+            ...cfDistributionProps,
+            // these values can NOT be overwritten by cfDistributionProps
+            domainNames: this.buildDistributionDomainNames(),
+            certificate: this.cdk.certificate,
+            defaultBehavior: defaultBehavior,
+            additionalBehaviors: {
+                "api/*": serverBehavior,
+                "_next/data/*": serverBehavior,
+                "_next/image*": imageBehavior,
+                "_next/*": staticFileBehaviour,
+                ...(cfDistributionProps.additionalBehaviors || {}),
+            },
+        });
+    }
+    createCloudFrontDistributionForStub() {
+        // Keep creating middleware edge function b/c edge function cannot be removed
+        // immediately.
+        this.createMiddlewareEdgeFunctionForRegional();
+        // Create placeholder distribution
+        return new cloudfront.Distribution(this, "Distribution", {
+            defaultRootObject: "index.html",
+            errorResponses: buildErrorResponsesForRedirectToIndex("index.html"),
+            domainNames: this.buildDistributionDomainNames(),
+            certificate: this.cdk.certificate,
+            defaultBehavior: {
+                origin: new origins.S3Origin(this.cdk.bucket),
+                viewerProtocolPolicy: cloudfront.ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
+            },
+        });
+    }
+    createCloudFrontServerCachePolicy() {
+        return new cloudfront.CachePolicy(this, "ServerCache", {
+            queryStringBehavior: cloudfront.CacheQueryStringBehavior.all(),
+            headerBehavior: cloudfront.CacheHeaderBehavior.allowList(
+            // required by image optimization request
+            "accept", 
+            // required by server request
+            "x-op-middleware-request-headers", "x-op-middleware-response-headers", "x-nextjs-data", "x-middleware-prefetch"),
+            cookieBehavior: cloudfront.CacheCookieBehavior.all(),
+            defaultTtl: Duration.days(0),
+            maxTtl: Duration.days(365),
+            minTtl: Duration.days(0),
+            enableAcceptEncodingBrotli: true,
+            enableAcceptEncodingGzip: true,
+            comment: "SST server response cache policy",
+        });
+    }
+    generateBuildId() {
+        if (this.isPlaceholder) {
+            return "live";
+        }
+        const filePath = path.join(this.props.path, ".next/BUILD_ID");
+        return fs.readFileSync(filePath).toString();
+    }
+    createImageOptimizationFunctionForRegional() {
+        const { defaults, path: sitePath } = this.props;
+        let bundlePath, handler;
+        if (this.isPlaceholder) {
+            bundlePath = path.resolve(__dirname, "../support/ssr-site-function-stub");
+            handler = "server.handler";
+        }
+        else {
+            bundlePath = path.join(sitePath, ".open-next/image-optimization-function");
+            handler = "index.handler";
+        }
+        return new lambda.Function(this, `ImageFunction`, {
+            description: "Image optimization handler for Next.js",
+            handler,
+            currentVersionOptions: {
+                removalPolicy: RemovalPolicy.DESTROY,
+            },
+            logRetention: logs.RetentionDays.THREE_DAYS,
+            code: lambda.Code.fromAsset(bundlePath),
+            runtime: lambda.Runtime.NODEJS_18_X,
+            memorySize: defaults?.function?.memorySize || 512,
+            timeout: Duration.seconds(defaults?.function?.timeout || 10),
+            environment: {
+                BUCKET_NAME: this.cdk.bucket.bucketName,
+            }
+        });
+    }
+    createMiddlewareEdgeFunctionForRegional() {
+        const { defaults, environment, path: sitePath } = this.props;
+        const middlewarePath = path.resolve(sitePath, ".open-next/middleware-function");
+        const isMiddlewareEnabled = fs.existsSync(middlewarePath);
+        let bundlePath, handler;
+        if (this.isPlaceholder || !isMiddlewareEnabled) {
+            bundlePath = path.resolve(__dirname, "../support/ssr-site-function-stub");
+            handler = "server.handler";
+        }
+        else {
+            bundlePath = middlewarePath;
+            handler = "index.handler";
+        }
+        const fn = new EdgeFunction(this, "Middleware", {
+            bundlePath,
+            handler,
+            timeout: 5,
+            memory: 128,
+            permissions: defaults?.function?.permissions,
+            environment,
+            format: "esm",
+        });
+        return { fn, isMiddlewareEnabled };
+    }
+}

package/{dist/constructs → constructs}/Parameter.js

@@ -12,6 +12,9 @@ import { Construct } from "constructs";
  * ```
  */
 export class Parameter extends Construct {
+    id;
+    name;
+    value;
     constructor(scope, id, props) {
         super(scope, id);
         this.id = id;

package/{dist/constructs → constructs}/Queue.js

@@ -2,7 +2,7 @@ import { Construct } from "constructs";
 import * as sqs from "aws-cdk-lib/aws-sqs";
 import * as lambdaEventSources from "aws-cdk-lib/aws-lambda-event-sources";
 import { getFunctionRef, isCDKConstruct } from "./Construct.js";
-import { Function as Fn, } from "./Function.js";
+import { Function as Fn } from "./Function.js";
 import { toCdkDuration } from "./util/duration.js";
 /////////////////////
 // Construct
@@ -21,10 +21,17 @@ import { toCdkDuration } from "./util/duration.js";
  * ```
  */
 export class Queue extends Construct {
+    id;
+    cdk;
+    /**
+     * The internally created consumer `Function` instance.
+     */
+    consumerFunction;
+    bindingForAllConsumers = [];
+    permissionsAttachedForAllConsumers = [];
+    props;
     constructor(scope, id, props) {
         super(scope, props?.cdk?.id || id);
-        this.bindingForAllConsumers = [];
-        this.permissionsAttachedForAllConsumers = [];
         this.id = id;
         this.props = props || {};
         this.cdk = {};
@@ -98,7 +105,7 @@ export class Queue extends Construct {
         const fn = Fn.fromDefinition(scope, `Consumer_${this.node.id}`, functionDefinition);
         fn.addEventSource(new lambdaEventSources.SqsEventSource(this.cdk.queue, eventSourceProps));
         // Attach permissions
-        this.permissionsAttachedForAllConsumers.forEach((permissions) => {
+        this.permissionsAttachedForAllConsumers.forEach(permissions => {
             fn.attachPermissions(permissions);
         });
         fn.bind(this.bindingForAllConsumers);
@@ -144,8 +151,8 @@ export class Queue extends Construct {
             data: {
                 name: this.cdk.queue.queueName,
                 url: this.cdk.queue.queueUrl,
-                consumer: getFunctionRef(this.consumerFunction),
-            },
+                consumer: getFunctionRef(this.consumerFunction)
+            }
         };
     }
     /** @internal */
@@ -155,12 +162,12 @@ export class Queue extends Construct {
             variables: {
                 queueUrl: {
                     environment: this.queueUrl,
-                    parameter: this.queueUrl,
-                },
+                    parameter: this.queueUrl
+                }
             },
             permissions: {
-                "sqs:*": [this.queueArn],
-            },
+                "sqs:*": [this.queueArn]
+            }
         };
     }
     createQueue() {
@@ -184,7 +191,7 @@ export class Queue extends Construct {
                     // TODO
                     console.log(toCdkDuration("900 seconds"));
                     debugOverrideProps = {
-                        visibilityTimeout: toCdkDuration("900 seconds"),
+                        visibilityTimeout: toCdkDuration("900 seconds")
                     };
                 }
             }
@@ -192,7 +199,7 @@ export class Queue extends Construct {
             this.cdk.queue = new sqs.Queue(this, "Queue", {
                 queueName: name,
                 ...sqsQueueProps,
-                ...debugOverrideProps,
+                ...debugOverrideProps
             });
         }
     }

package/{dist/constructs → constructs}/RDS.js

@@ -1,6 +1,6 @@
 import path from "path";
 import glob from "glob";
-import fs from "fs-extra";
+import fs from "fs";
 import * as crypto from "crypto";
 import { Construct } from "constructs";
 import * as cdk from "aws-cdk-lib";
@@ -29,13 +29,21 @@ const __dirname = url.fileURLToPath(new URL(".", import.meta.url));
  * ```
  */
 export class RDS extends Construct {
+    id;
+    cdk;
+    /**
+     * The ARN of the internally created CDK ServerlessCluster instance.
+     */
+    migratorFunction;
+    props;
+    secret;
     constructor(scope, id, props) {
         super(scope, props.cdk?.id || id);
         this.validateRequiredProps(props);
         this.id = id;
         this.cdk = {};
         this.props = props || {};
-        const { migrations, cdk } = this.props;
+        let { migrations, cdk } = this.props;
         // Create the cluster
         if (cdk && isCDKConstruct(cdk.cluster)) {
             this.validateCDKPropWhenIsConstruct();
@@ -114,12 +122,12 @@ export class RDS extends Construct {
                 },
                 secretArn: {
                     environment: this.secretArn,
-                    parameter: this.secretArn
+                    parameter: this.secretArn,
                 },
                 defaultDatabaseName: {
                     environment: this.defaultDatabaseName,
-                    parameter: this.defaultDatabaseName
-                }
+                    parameter: this.defaultDatabaseName,
+                },
             },
             permissions: {
                 "rds-data:*": [this.clusterArn],
@@ -250,10 +258,8 @@ export class RDS extends Construct {
         // - when invoked from `sst build`, __dirname is `resources/dist`
         // - when running resources tests, __dirname is `resources/src`
         // For now we will do `__dirname/../dist` to make both cases work.
-        const srcPath = path.resolve(path.join(__dirname, "../dist/RDS_migrator"));
         const fn = new Fn(this, "MigrationFunction", {
-            srcPath,
-            handler: "index.handler",
+            handler: path.resolve(path.join(__dirname, "../support/rds-migrator/index.handler")),
             runtime: "nodejs16.x",
             timeout: 900,
             memorySize: 1024,
@@ -266,20 +272,21 @@ export class RDS extends Construct {
                 // can locate the migration files
                 RDS_MIGRATIONS_PATH: app.local ? migrations : migrationsDestination,
             },
-            bundle: {
-                nodeModules: ["kysely", "kysely-data-api"],
+            // Note that we need to generate a relative path of the migrations off the
+            // srcPath because sst.Function internally builds the copy "from" path by
+            // joining the srcPath and the from path.
+            copyFiles: [
+                {
+                    from: migrations,
+                    to: migrationsDestination,
+                },
+            ],
+            nodejs: {
+                install: ["kysely", "kysely-data-api"],
                 format: "esm",
-                // Note that we need to generate a relative path of the migrations off the
-                // srcPath because sst.Function internally builds the copy "from" path by
-                // joining the srcPath and the from path.
-                copyFiles: [
-                    {
-                        from: path.relative(path.resolve(srcPath), path.resolve(migrations)),
-                        to: migrationsDestination,
-                    },
-                ],
             },
         });
+        fn._disableBind = true;
         fn.attachPermissions([this.cdk.cluster]);
         this.migratorFunction = fn;
     }

package/{dist/constructs → constructs}/ReactStaticSite.js

@@ -1,5 +1,5 @@
 import * as path from "path";
-import fs from "fs-extra";
+import fs from "fs";
 import { StaticSite } from "./StaticSite.js";
 /////////////////////
 // Construct

package/constructs/RemixSite.d.ts

@@ -0,0 +1,28 @@
+import * as lambda from "aws-cdk-lib/aws-lambda";
+import { SsrSite } from "./SsrSite.js";
+import { EdgeFunction } from "./EdgeFunction.js";
+/**
+ * The `RemixSite` construct is a higher level CDK construct that makes it easy to create a Remix app.
+ *
+ * @example
+ *
+ * Deploys a Remix app in the `my-remix-app` directory.
+ *
+ * ```js
+ * new RemixSite(stack, "web", {
+ *   path: "my-remix-app/",
+ * });
+ * ```
+ */
+export declare class RemixSite extends SsrSite {
+    protected initBuildConfig(): {
+        serverBuildOutputFile: string;
+        clientBuildOutputDir: string;
+        clientBuildVersionedSubDir: string;
+        siteStub: string;
+    };
+    private createServerLambdaBundle;
+    private createServerLambdaBundleWithStub;
+    protected createFunctionForRegional(): lambda.Function;
+    protected createFunctionForEdge(): EdgeFunction;
+}

package/constructs/RemixSite.js

@@ -0,0 +1,150 @@
+import fs from "fs";
+import url from "url";
+import path from "path";
+import * as esbuild from "esbuild";
+import { createRequire } from "module";
+const require = createRequire(import.meta.url);
+import { Duration, RemovalPolicy } from "aws-cdk-lib";
+import * as logs from "aws-cdk-lib/aws-logs";
+import * as lambda from "aws-cdk-lib/aws-lambda";
+import { Logger } from "../logger.js";
+import { SsrSite } from "./SsrSite.js";
+import { EdgeFunction } from "./EdgeFunction.js";
+const __dirname = url.fileURLToPath(new URL(".", import.meta.url));
+/**
+ * The `RemixSite` construct is a higher level CDK construct that makes it easy to create a Remix app.
+ *
+ * @example
+ *
+ * Deploys a Remix app in the `my-remix-app` directory.
+ *
+ * ```js
+ * new RemixSite(stack, "web", {
+ *   path: "my-remix-app/",
+ * });
+ * ```
+ */
+export class RemixSite extends SsrSite {
+    initBuildConfig() {
+        const { path: sitePath } = this.props;
+        const configDefaults = {
+            assetsBuildDirectory: "public/build",
+            publicPath: "/build/",
+            serverBuildPath: "build/index.js",
+            serverBuildTarget: "node-cjs",
+        };
+        // Validate config path
+        const configPath = path.resolve(sitePath, "remix.config.js");
+        if (!fs.existsSync(configPath)) {
+            throw new Error(`Could not find "remix.config.js" at expected path "${configPath}".`);
+        }
+        // Load config
+        const userConfig = require(configPath);
+        const config = {
+            ...configDefaults,
+            ...userConfig,
+        };
+        // Validate config
+        Object.keys(configDefaults).forEach((key) => {
+            const k = key;
+            if (config[k] !== configDefaults[k]) {
+                throw new Error(`RemixSite: remix.config.js "${key}" must be "${configDefaults[k]}".`);
+            }
+        });
+        return {
+            serverBuildOutputFile: "build/index.js",
+            clientBuildOutputDir: "public",
+            clientBuildVersionedSubDir: "build",
+            siteStub: path.resolve(__dirname, "../support/remix-site-html-stub"),
+        };
+    }
+    createServerLambdaBundle(wrapperFile) {
+        // Create a Lambda@Edge handler for the Remix server bundle.
+        //
+        // Note: Remix does perform their own internal ESBuild process, but it
+        // doesn't bundle 3rd party dependencies by default. In the interest of
+        // keeping deployments seamless for users we will create a server bundle
+        // with all dependencies included. We will still need to consider how to
+        // address any need for external dependencies, although I think we should
+        // possibly consider this at a later date.
+        // In this path we are assuming that the Remix build only outputs the
+        // "core server build". We can safely assume this as we have guarded the
+        // remix.config.js to ensure it matches our expectations for the build
+        // configuration.
+        // We need to ensure that the "core server build" is wrapped with an
+        // appropriate Lambda@Edge handler. We will utilise an internal asset
+        // template to create this wrapper within the "core server build" output
+        // directory.
+        Logger.debug(`Creating Lambda@Edge handler for server`);
+        // Resolve the path to create the server lambda handler at.
+        const serverPath = path.join(this.props.path, "build/server.js");
+        // Write the server lambda
+        const templatePath = path.resolve(__dirname, `../support/remix-site-function/${wrapperFile}`);
+        fs.copyFileSync(templatePath, serverPath);
+        Logger.debug(`Bundling server`);
+        // Create a directory that we will use to create the bundled version
+        // of the "core server build" along with our custom Lamba server handler.
+        const outputPath = path.resolve(path.join(this.sstBuildDir, `RemixSiteFunction-${this.node.id}-${this.node.addr}`));
+        // Copy the Remix polyfil to the server build directory
+        const polyfillSource = path.resolve(__dirname, "../support/remix-site-function/polyfill.js");
+        const polyfillDest = path.join(this.props.path, "build/polyfill.js");
+        fs.copyFileSync(polyfillSource, polyfillDest);
+        const result = esbuild.buildSync({
+            entryPoints: [serverPath],
+            bundle: true,
+            target: "node16",
+            platform: "node",
+            external: ["aws-sdk"],
+            outfile: path.join(outputPath, "server.js"),
+            // We need to ensure that the polyfills are injected above other code that
+            // will depend on them. Importing them within the top of the lambda code
+            // doesn't appear to guarantee this, we therefore leverage ESBUild's
+            // `inject` option to ensure that the polyfills are injected at the top of
+            // the bundle.
+            inject: [polyfillDest],
+        });
+        if (result.errors.length > 0) {
+            result.errors.forEach((error) => console.error(error));
+            throw new Error(`There was a problem bundling the server.`);
+        }
+        return outputPath;
+    }
+    createServerLambdaBundleWithStub() {
+        // Use existing stub bundle in assets
+        return path.resolve(__dirname, "../support/ssr-site-function-stub");
+    }
+    createFunctionForRegional() {
+        const { defaults, environment } = this.props;
+        const bundlePath = this.isPlaceholder
+            ? this.createServerLambdaBundleWithStub()
+            : this.createServerLambdaBundle("regional-server.js");
+        return new lambda.Function(this, `ServerFunction`, {
+            description: "Server handler for Remix",
+            handler: "server.handler",
+            currentVersionOptions: {
+                removalPolicy: RemovalPolicy.DESTROY,
+            },
+            logRetention: logs.RetentionDays.THREE_DAYS,
+            code: lambda.Code.fromAsset(bundlePath),
+            runtime: lambda.Runtime.NODEJS_16_X,
+            memorySize: defaults?.function?.memorySize || 512,
+            timeout: Duration.seconds(defaults?.function?.timeout || 10),
+            environment,
+        });
+    }
+    createFunctionForEdge() {
+        const { defaults, environment } = this.props;
+        const bundlePath = this.isPlaceholder
+            ? this.createServerLambdaBundleWithStub()
+            : this.createServerLambdaBundle("edge-server.js");
+        return new EdgeFunction(this, `Server`, {
+            scopeOverride: this,
+            bundlePath,
+            handler: "server.handler",
+            timeout: defaults?.function?.timeout,
+            memory: defaults?.function?.memorySize,
+            permissions: defaults?.function?.permissions,
+            environment,
+        });
+    }
+}

package/constructs/RemixSite.tsdoc.d.ts

@@ -0,0 +1,2 @@
+export * from "./RemixSite.js";
+export * from "./SsrSite.js";

package/constructs/RemixSite.tsdoc.js

@@ -0,0 +1,2 @@
+export * from "./RemixSite.js";
+export * from "./SsrSite.js";