sst 2.1.16 → 2.1.18

package/constructs/EdgeFunction.js

@@ -2,12 +2,15 @@ import fs from "fs";
 import url from "url";
 import path from "path";
 import crypto from "crypto";
+import { buildSync } from "esbuild";
 import { Construct } from "constructs";
 import { Effect, Role, Policy, PolicyStatement, CompositePrincipal, ServicePrincipal, ManagedPolicy, } from "aws-cdk-lib/aws-iam";
-import * as lambda from "aws-cdk-lib/aws-lambda";
-import * as s3Assets from "aws-cdk-lib/aws-s3-assets";
+import { Version, Code, Runtime, Function as CdkFunction, } from "aws-cdk-lib/aws-lambda";
+import { Asset } from "aws-cdk-lib/aws-s3-assets";
 import { Lazy, Duration as CdkDuration, CustomResource, } from "aws-cdk-lib";
+import { useProject } from "../project.js";
 import { Stack } from "./Stack.js";
+import { bindEnvironment, bindPermissions, getReferencedSecrets, } from "./util/functionBinding.js";
 import { toCdkSize } from "./util/size.js";
 import { toCdkDuration } from "./util/duration.js";
 import { attachPermissionsToRole } from "./util/permission.js";
@@ -20,132 +23,174 @@ export class EdgeFunction extends Construct {
     functionArn;
     scope;
     versionId;
+    bindingEnvs;
     props;
     constructor(scope, id, props) {
         super(scope, id);
-        this.props = props;
-        const { scopeOverride } = props;
-        // Correct scope
-        this.scope = scopeOverride || this;
-        // Wrap function code
-        this.wrapFunctionCode();
-        // Create function asset
-        const asset = this.createAsset();
-        // Create function role
+        // Override scope
+        // note: this is intended to be used internally by SST to make constructs
+        //       backwards compatible when the hirechical structure of the constructs
+        //       changes. When the hirerchical structure changes, the child AWS
+        //       resources' logical ID will change. And CloudFormation will recreate
+        //       them.
+        this.scope = props.scopeOverride || this;
+        this.props = {
+            ...props,
+            bundle: props.bundle || "placeholder",
+            environment: props.environment || {},
+            permissions: props.permissions || [],
+        };
+        // Build bundle if not prebuilt
+        const { bundle, handler, handlerFilename } = props.bundle
+            ? this.updateBundleWithEnvWrapper()
+            : this.buildBundle();
+        this.props.bundle = bundle;
+        this.props.handler = handler;
+        // Bind first b/e function's environment variables cannot be added after
+        this.bindingEnvs = {};
+        this.bind(props.bind || []);
+        const asset = this.createCodeAsset();
+        const assetReplacer = this.createCodeReplacer(asset, handlerFilename);
         this.role = this.createRole();
-        // Create function
-        const { functionArn, versionId } = this.createFunction(asset);
-        this.functionArn = functionArn;
+        const bucket = this.createSingletonBucketInUsEast1();
+        const { fn, fnArn } = this.createFunctionInUsEast1(asset, bucket);
+        const { versionId } = this.createVersionInUsEast1(fn, fnArn);
+        // Deploy after the code is updated
+        fn.node.addDependency(assetReplacer);
+        this.functionArn = fnArn;
         this.versionId = versionId;
     }
     get currentVersion() {
-        return lambda.Version.fromVersionArn(this, `${this.node.id}FunctionVersion`, `${this.functionArn}:${this.versionId}`);
+        return Version.fromVersionArn(this, `${this.node.id}FunctionVersion`, `${this.functionArn}:${this.versionId}`);
     }
     attachPermissions(permissions) {
         attachPermissionsToRole(this.role, permissions);
     }
-    wrapFunctionCode() {
-        const { bundlePath, format } = this.props;
-        // Parse handler
-        const parts = this.props.handler.split(".");
-        const handlerImportPath = parts.slice(0, -1).join(".");
-        const handlerMethod = parts.slice(-1)[0];
-        const handlerExt = [".js", ".jsx", ".mjs", ".cjs"].find((ext) => fs.existsSync(path.join(bundlePath, handlerImportPath + ext)));
-        const imports = this.props.format === "esm"
-            ? `import * as index from "./${handlerImportPath}${handlerExt}";`
-            : `"use strict"; const index = require("./${handlerImportPath}");`;
-        const exports = this.props.format === "esm"
-            ? `export { handler };`
-            : `exports.handler = handler;`;
-        const content = `${imports}
-const handler = async (event) => {
-  try {
-    // We expose an environment variable token which is used by the code
-    // replacer to inject the environment variables assigned to the
-    // EdgeFunction construct.
-    //
-    // "{{ _SST_FUNCTION_ENVIRONMENT_ }}" will get replaced during
-    // deployment with an object of environment key-value pairs, ie.
-    // const environment = {"API_URL": "https://api.example.com"};
-    //
-    // This inlining strategy is required as Lambda@Edge doesn't natively
-    // support runtime environment variables. A downside of this approach
-    // is that environment variables cannot be toggled after deployment,
-    // each change to one requires a redeployment.
-    const environment = "{{ _SST_FUNCTION_ENVIRONMENT_ }}";
-    process.env = { ...process.env, ...environment };
-  } catch (e) {
-    console.log("Failed to set SST Lambda@Edge environment.");
-    console.log(e);
-  }
-
-  return await index.${handlerMethod}(event);
-};
-
-${exports}
-`;
-        fs.writeFileSync(path.join(bundlePath, `index-wrapper.${format === "esm" ? "mjs" : "cjs"}`), content);
-    }
-    createAsset() {
-        const { bundlePath } = this.props;
-        return new s3Assets.Asset(this.scope, `FunctionAsset`, {
-            path: bundlePath,
-        });
-    }
-    createRole() {
-        const { permissions } = this.props;
-        // Create function role
-        const role = new Role(this.scope, `ServerLambdaRole`, {
-            assumedBy: new CompositePrincipal(new ServicePrincipal("lambda.amazonaws.com"), new ServicePrincipal("edgelambda.amazonaws.com")),
-            managedPolicies: [
-                ManagedPolicy.fromManagedPolicyArn(this, "EdgeLambdaPolicy", `arn:${Stack.of(this).partition}:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole`),
+    buildBundle() {
+        const { handler, format, esbuild, runtime } = this.props;
+        const isESM = format === "esm";
+        const { dir: inputPath, base: inputHandler, name: inputFilename, ext: inputHandlerFunction, } = path.parse(handler);
+        const inputFileExt = this.getHandlerExtension(path.join(inputPath, inputFilename));
+        // 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(useProject().paths.artifacts, `EdgeFunction-${this.node.id}-${this.node.addr}`));
+        const outputHandler = inputHandler;
+        const outputFilename = inputFilename;
+        const outputFileExt = isESM ? ".mjs" : ".cjs";
+        const { external, ...override } = esbuild || {};
+        const result = buildSync({
+            entryPoints: [handler.replace(inputHandlerFunction, inputFileExt)],
+            platform: "node",
+            external: [
+                ...(isESM || runtime === "nodejs18.x" ? [] : ["aws-sdk"]),
+                ...(external || []),
             ],
+            metafile: true,
+            bundle: true,
+            ...(isESM
+                ? {
+                    format: "esm",
+                    target: "esnext",
+                    mainFields: ["module", "main"],
+                    banner: {
+                        js: [
+                            `import { createRequire as topLevelCreateRequire } from 'module';`,
+                            `const require = topLevelCreateRequire(import.meta.url);`,
+                            `import { fileURLToPath as topLevelFileUrlToPath } from "url"`,
+                            `const __dirname = topLevelFileUrlToPath(new URL(".", import.meta.url))`,
+                            `process.env = { ...process.env, ..."{{ _SST_FUNCTION_ENVIRONMENT_ }}" };`,
+                        ].join("\n"),
+                    },
+                }
+                : {
+                    format: "cjs",
+                    target: "node14",
+                }),
+            outfile: path.join(outputPath, outputFilename + outputFileExt),
+            ...override,
         });
-        // Attach permission
-        if (permissions) {
-            attachPermissionsToRole(role, permissions);
+        if (result.errors.length > 0) {
+            result.errors.forEach((error) => console.error(error));
+            throw new Error(`There was a problem bundling the SSR function for the "${this.scope.node.id}" Site.`);
         }
-        return role;
+        return {
+            bundle: outputPath,
+            handler: outputHandler,
+            handlerFilename: outputFilename + outputFileExt,
+        };
     }
-    createFunction(asset) {
-        const { runtime, timeout, memorySize } = this.props;
-        const name = this.node.id;
-        // Create a S3 bucket in us-east-1 to store Lambda code. Create
-        // 1 bucket for all Edge functions.
-        const bucketCR = this.createSingletonBucketCR();
-        const bucketName = bucketCR.getAttString("BucketName");
-        // Create a Lambda function in us-east-1
-        const functionCR = this.createFunctionCR(name, this.role, bucketName, {
-            Description: `${name} handler`,
-            Handler: "index-wrapper.handler",
-            Code: {
-                S3Bucket: asset.s3BucketName,
-                S3Key: asset.s3ObjectKey,
-            },
-            Runtime: runtime === "nodejs14.x"
-                ? lambda.Runtime.NODEJS_14_X.name
-                : runtime === "nodejs16.x"
-                    ? lambda.Runtime.NODEJS_16_X.name
-                    : lambda.Runtime.NODEJS_18_X.name,
-            MemorySize: typeof memorySize === "string"
-                ? toCdkSize(memorySize).toMebibytes()
-                : memorySize,
-            Timeout: typeof timeout === "string"
-                ? toCdkDuration(timeout).toSeconds()
-                : timeout,
-            Role: this.role.roleArn,
+    updateBundleWithEnvWrapper() {
+        // We expose an environment variable token which is used by the code
+        // replacer to inject the environment variables assigned to the
+        // EdgeFunction construct.
+        //
+        // "{{ _SST_FUNCTION_ENVIRONMENT_ }}" will get replaced during
+        // deployment with an object of environment key-value pairs, ie.
+        // const environment = {"API_URL": "https://api.example.com"};
+        //
+        // This inlining strategy is required as Lambda@Edge doesn't natively
+        // support runtime environment variables. A downside of this approach
+        // is that environment variables cannot be toggled after deployment,
+        // each change to one requires a redeployment.
+        const { bundle, handler } = this.props;
+        const { dir: inputPath, name: inputFilename, ext: inputHandlerFunction, } = path.parse(handler);
+        const inputFileExt = this.getHandlerExtension(path.join(bundle, inputPath, inputFilename));
+        const handlerFilename = handler.replace(inputHandlerFunction, inputFileExt);
+        const filePath = path.join(bundle, handlerFilename);
+        const fileData = fs.readFileSync(filePath, "utf8");
+        fs.writeFileSync(filePath, `process.env = { ...process.env, ..."{{ _SST_FUNCTION_ENVIRONMENT_ }}" };\n${fileData}`);
+        return { bundle, handler, handlerFilename };
+    }
+    bind(constructs) {
+        const app = this.node.root;
+        this.bindingEnvs = {
+            SST_APP: app.name,
+            SST_STAGE: app.stage,
+            SST_REGION: app.region,
+            SST_SSM_PREFIX: useProject().config.ssmPrefix,
+        };
+        // Get referenced secrets
+        const referencedSecrets = [];
+        constructs.forEach((c) => referencedSecrets.push(...getReferencedSecrets(c)));
+        [...constructs, ...referencedSecrets].forEach((c) => {
+            // Bind environment
+            this.bindingEnvs = {
+                ...this.bindingEnvs,
+                ...bindEnvironment(c),
+            };
+            // Bind permissions
+            if (this.props.permissions !== "*") {
+                this.props.permissions.push(...Object.entries(bindPermissions(c)).map(([action, resources]) => new PolicyStatement({
+                    actions: [action],
+                    effect: Effect.ALLOW,
+                    resources,
+                })));
+            }
+        });
+    }
+    createCodeAsset() {
+        const { bundle } = this.props;
+        return new Asset(this.scope, `FunctionAsset`, {
+            path: bundle,
         });
-        const functionArn = functionCR.getAttString("FunctionArn");
-        // Create a Lambda function version in us-east-1
-        const versionCR = this.createVersionCR(name, functionArn);
-        const versionId = versionCR.getAttString("Version");
-        this.updateVersionLogicalId(functionCR, versionCR);
-        // Deploy after the code is updated
-        const updaterCR = this.createLambdaCodeReplacer(asset);
-        functionCR.node.addDependency(updaterCR);
-        return { functionArn, versionId };
     }
-    createLambdaCodeReplacer(asset) {
+    createCodeReplacer(asset, handlerFilename) {
+        const { environment } = this.props;
+        const replacements = [
+            {
+                files: handlerFilename,
+                search: '"{{ _SST_FUNCTION_ENVIRONMENT_ }}"',
+                replace: JSON.stringify({
+                    ...environment,
+                    ...this.bindingEnvs,
+                }),
+            },
+            ...Object.entries(environment).map(([key, value]) => ({
+                files: "**/*.*js",
+                search: `{{ ${key} }}`,
+                replace: value,
+            })),
+        ];
         // 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.
@@ -166,13 +211,30 @@ ${exports}
             properties: {
                 bucket: asset.s3BucketName,
                 key: asset.s3ObjectKey,
-                replacements: this.getLambdaContentReplaceValues(),
+                replacements,
             },
         });
         resource.node.addDependency(policy);
         return resource;
     }
-    createSingletonBucketCR() {
+    createRole() {
+        const { permissions } = this.props;
+        // Create function role
+        const role = new Role(this.scope, `ServerLambdaRole`, {
+            assumedBy: new CompositePrincipal(new ServicePrincipal("lambda.amazonaws.com"), new ServicePrincipal("edgelambda.amazonaws.com")),
+            managedPolicies: [
+                ManagedPolicy.fromManagedPolicyArn(this, "EdgeLambdaPolicy", `arn:${Stack.of(this).partition}:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole`),
+            ],
+        });
+        // Attach permission
+        if (permissions) {
+            attachPermissionsToRole(role, permissions);
+        }
+        return role;
+    }
+    createSingletonBucketInUsEast1() {
+        // Create a S3 bucket in us-east-1 to store Lambda code. Create
+        // 1 bucket for all Edge functions.
         // Do not recreate if exist
         const providerId = "EdgeLambdaBucketProvider";
         const resId = "EdgeLambdaBucket";
@@ -182,10 +244,10 @@ ${exports}
             return existingResource;
         }
         // Create provider
-        const provider = new lambda.Function(stack, providerId, {
-            code: lambda.Code.fromAsset(path.join(__dirname, "../support/edge-function")),
+        const provider = new CdkFunction(stack, providerId, {
+            code: Code.fromAsset(path.join(__dirname, "../support/edge-function")),
             handler: "s3-bucket.handler",
-            runtime: lambda.Runtime.NODEJS_16_X,
+            runtime: Runtime.NODEJS_16_X,
             timeout: CdkDuration.minutes(15),
             memorySize: 1024,
             initialPolicy: [
@@ -206,18 +268,19 @@ ${exports}
         });
         return resource;
     }
-    createFunctionCR(name, role, bucketName, functionParams) {
+    createFunctionInUsEast1(asset, bucket) {
+        const { handler, runtime, timeout, memorySize } = this.props;
         // Do not recreate if exist
         const providerId = "EdgeLambdaProvider";
-        const resId = `${name}EdgeLambda`;
+        const resId = `${this.node.id}EdgeLambda`;
         const stack = Stack.of(this);
         let provider = stack.node.tryFindChild(providerId);
         // Create provider if not already created
         if (!provider) {
-            provider = new lambda.Function(stack, providerId, {
-                code: lambda.Code.fromAsset(path.join(__dirname, "../support/edge-function")),
+            provider = new CdkFunction(stack, providerId, {
+                code: Code.fromAsset(path.join(__dirname, "../support/edge-function")),
                 handler: "edge-lambda.handler",
-                runtime: lambda.Runtime.NODEJS_16_X,
+                runtime: Runtime.NODEJS_16_X,
                 timeout: CdkDuration.minutes(15),
                 memorySize: 1024,
                 initialPolicy: [
@@ -229,33 +292,52 @@ ${exports}
                 ],
             });
             if (provider.role) {
-                role.grantPassRole(provider.role);
+                this.role.grantPassRole(provider.role);
             }
         }
         // Create custom resource
-        const resource = new CustomResource(this.scope, resId, {
+        const fn = new CustomResource(this.scope, resId, {
             serviceToken: provider.functionArn,
             resourceType: "Custom::SSTEdgeLambda",
             properties: {
                 FunctionNamePrefix: `${Stack.of(this).stackName}-${resId}`,
-                FunctionBucket: bucketName,
-                FunctionParams: functionParams,
+                FunctionBucket: bucket.getAttString("BucketName"),
+                FunctionParams: {
+                    Description: `${this.node.id} handler`,
+                    Handler: handler,
+                    Code: {
+                        S3Bucket: asset.s3BucketName,
+                        S3Key: asset.s3ObjectKey,
+                    },
+                    Runtime: runtime === "nodejs14.x"
+                        ? Runtime.NODEJS_14_X.name
+                        : runtime === "nodejs16.x"
+                            ? Runtime.NODEJS_16_X.name
+                            : Runtime.NODEJS_18_X.name,
+                    MemorySize: typeof memorySize === "string"
+                        ? toCdkSize(memorySize).toMebibytes()
+                        : memorySize,
+                    Timeout: typeof timeout === "string"
+                        ? toCdkDuration(timeout).toSeconds()
+                        : timeout,
+                    Role: this.role.roleArn,
+                },
             },
         });
-        return resource;
+        return { fn, fnArn: fn.getAttString("FunctionArn") };
     }
-    createVersionCR(name, functionArn) {
+    createVersionInUsEast1(fn, fnArn) {
         // Do not recreate if exist
         const providerId = "EdgeLambdaVersionProvider";
-        const resId = `${name}EdgeLambdaVersion`;
+        const resId = `${this.node.id}EdgeLambdaVersion`;
         const stack = Stack.of(this);
         let provider = stack.node.tryFindChild(providerId);
         // Create provider if not already created
         if (!provider) {
-            provider = new lambda.Function(stack, providerId, {
-                code: lambda.Code.fromAsset(path.join(__dirname, "../support/edge-function")),
+            provider = new CdkFunction(stack, providerId, {
+                code: Code.fromAsset(path.join(__dirname, "../support/edge-function")),
                 handler: "edge-lambda-version.handler",
-                runtime: lambda.Runtime.NODEJS_16_X,
+                runtime: Runtime.NODEJS_16_X,
                 timeout: CdkDuration.minutes(15),
                 memorySize: 1024,
                 initialPolicy: [
@@ -268,56 +350,42 @@ ${exports}
             });
         }
         // Create custom resource
-        return new CustomResource(this.scope, resId, {
+        const version = new CustomResource(this.scope, resId, {
             serviceToken: provider.functionArn,
             resourceType: "Custom::SSTEdgeLambdaVersion",
             properties: {
-                FunctionArn: functionArn,
+                FunctionArn: fnArn,
             },
         });
-    }
-    /////////////////////
-    // Internal Functions
-    /////////////////////
-    getLambdaContentReplaceValues() {
-        const { format } = this.props;
-        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,
-            });
-        });
-        replaceValues.push({
-            files: `index-wrapper.${format === "esm" ? "mjs" : "cjs"}`,
-            search: '"{{ _SST_FUNCTION_ENVIRONMENT_ }}"',
-            replace: JSON.stringify(this.props.environment || {}),
-        });
-        return replaceValues;
-    }
-    updateVersionLogicalId(functionCR, versionCR) {
         // Override the version's logical ID with a lazy string which includes the
         // hash of the function itself, so a new version resource is created when
         // the function configuration changes.
-        const cfn = versionCR.node.defaultChild;
-        const originalLogicalId = Stack.of(versionCR).resolve(cfn.logicalId);
+        const cfn = version.node.defaultChild;
+        const originalLogicalId = Stack.of(version).resolve(cfn.logicalId);
         cfn.overrideLogicalId(Lazy.uncachedString({
             produce: () => {
-                const hash = this.calculateHash(functionCR);
+                const hash = this.calculateHash(fn);
                 const logicalId = this.trimFromStart(originalLogicalId, 255 - 32);
                 return `${logicalId}${hash}`;
             },
         }));
+        return { version, versionId: version.getAttString("Version") };
+    }
+    getHandlerExtension(pathWithoutExtension) {
+        const ext = [
+            ".ts",
+            ".tsx",
+            ".mts",
+            ".cts",
+            ".js",
+            ".jsx",
+            ".mjs",
+            ".cjs",
+        ].find((ext) => fs.existsSync(pathWithoutExtension + ext));
+        if (!ext) {
+            throw new Error(`Cannot find the SSR function handler file for the "${this.scope.node.id}" Site.`);
+        }
+        return ext;
     }
     trimFromStart(s, maxLength) {
         const desiredLength = Math.min(maxLength, s.length);

package/constructs/Function.d.ts

@@ -538,7 +538,7 @@ export declare class Function extends lambda.Function implements SSTConstruct {
     readonly id: string;
     readonly _isLiveDevEnabled: boolean;
     /** @internal */
-    _disableBind?: boolean;
+    _doNotAllowOthersToBind?: boolean;
     private functionUrl?;
     private props;
     private allBindings;

package/constructs/Function.js

@@ -64,7 +64,7 @@ export class Function extends lambda.Function {
     id;
     _isLiveDevEnabled;
     /** @internal */
-    _disableBind;
+    _doNotAllowOthersToBind;
     functionUrl;
     props;
     allBindings = [];
@@ -429,7 +429,7 @@ export class Function extends lambda.Function {
                 ...(inheritedProps || {}),
                 handler: definition,
             });
-            fn._disableBind = true;
+            fn._doNotAllowOthersToBind = true;
             return fn;
         }
         else if (definition instanceof Function) {
@@ -444,7 +444,7 @@ export class Function extends lambda.Function {
         }
         else if (definition.handler !== undefined) {
             const fn = new Function(scope, id, Function.mergeProps(inheritedProps, definition));
-            fn._disableBind = true;
+            fn._doNotAllowOthersToBind = true;
             return fn;
         }
         throw new Error(`Invalid function definition for the "${id}" Function`);

package/constructs/Job.js

@@ -238,7 +238,7 @@ export class Job extends Construct {
             },
             permissions,
         });
-        fn._disableBind = true;
+        fn._doNotAllowOthersToBind = true;
         return fn;
     }
     createCodeBuildInvoker() {
@@ -262,7 +262,7 @@ export class Job extends Construct {
             },
             enableLiveDev: false,
         });
-        fn._disableBind = true;
+        fn._doNotAllowOthersToBind = true;
         return fn;
     }
     bindForCodeBuild(constructs) {

package/constructs/NextjsSite.d.ts

@@ -3,7 +3,6 @@ import * as lambda from "aws-cdk-lib/aws-lambda";
 import * as cloudfront from "aws-cdk-lib/aws-cloudfront";
 import { SsrSite, SsrSiteProps } from "./SsrSite.js";
 import { Size } from "./util/size.js";
-import { Duration } from "./util/duration.js";
 export interface NextjsSiteProps extends Omit<SsrSiteProps, "edge"> {
     imageOptimization?: {
         /**
@@ -29,10 +28,12 @@ export interface NextjsSiteProps extends Omit<SsrSiteProps, "edge"> {
  * ```
  */
 export declare class NextjsSite extends SsrSite {
-    protected props: Omit<NextjsSiteProps, "path"> & {
-        path: string;
-        timeout: number | Duration;
-        memorySize: number | Size;
+    protected props: NextjsSiteProps & {
+        path: Exclude<NextjsSiteProps["path"], undefined>;
+        runtime: Exclude<NextjsSiteProps["runtime"], undefined>;
+        timeout: Exclude<NextjsSiteProps["timeout"], undefined>;
+        memorySize: Exclude<NextjsSiteProps["memorySize"], undefined>;
+        waitForInvalidation: Exclude<NextjsSiteProps["waitForInvalidation"], undefined>;
     };
     constructor(scope: Construct, id: string, props?: NextjsSiteProps);
     protected initBuildConfig(): {

package/constructs/NextjsSite.js

@@ -38,14 +38,15 @@ export class NextjsSite extends SsrSite {
         };
     }
     createFunctionForRegional() {
-        const { runtime, timeout, memorySize, permissions, environment, cdk } = this.props;
+        const { runtime, timeout, memorySize, bind, permissions, environment, cdk, } = this.props;
         const ssrFn = new SsrFunction(this, `ServerFunction`, {
             description: "Server handler for Next.js",
-            bundlePath: path.join(this.props.path, ".open-next", "server-function"),
+            bundle: path.join(this.props.path, ".open-next", "server-function"),
             handler: "index.handler",
             runtime,
             timeout,
             memorySize,
+            bind,
             permissions,
             environment,
             ...cdk?.server,
@@ -86,8 +87,9 @@ export class NextjsSite extends SsrSite {
         const middlewarePath = path.resolve(sitePath, ".open-next/middleware-function");
         if (fs.existsSync(middlewarePath)) {
             return new EdgeFunction(this, "Middleware", {
-                bundlePath: middlewarePath,
+                bundle: middlewarePath,
                 handler: "index.handler",
+                runtime: "nodejs18.x",
                 timeout: 5,
                 memorySize: 128,
                 permissions,

package/constructs/RDS.js

@@ -290,7 +290,7 @@ export class RDS extends Construct {
                 format: "esm",
             },
         });
-        fn._disableBind = true;
+        fn._doNotAllowOthersToBind = true;
         fn.attachPermissions([this.cdk.cluster]);
         this.migratorFunction = fn;
     }

package/constructs/RemixSite.d.ts

@@ -1,4 +1,4 @@
-import * as lambda from "aws-cdk-lib/aws-lambda";
+import { Function as CdkFunction } from "aws-cdk-lib/aws-lambda";
 import { SsrSite } from "./SsrSite.js";
 import { EdgeFunction } from "./EdgeFunction.js";
 /**
@@ -21,7 +21,6 @@ export declare class RemixSite extends SsrSite {
         clientBuildVersionedSubDir: string;
     };
     private createServerLambdaBundle;
-    protected createFunctionForRegional(): lambda.Function;
+    protected createFunctionForRegional(): CdkFunction;
     protected createFunctionForEdge(): EdgeFunction;
-    private normalizeRuntime;
 }