sst 2.42.0 → 2.43.1

package/constructs/NextjsSite.js

@@ -1,35 +1,20 @@
 import fs from "fs";
 import path from "path";
-import zlib from "zlib";
 import crypto from "crypto";
-import { globSync } from "glob";
-import { Duration as CdkDuration, RemovalPolicy, CustomResource, } from "aws-cdk-lib/core";
-import { Code, Runtime, Function as CdkFunction, Architecture, LayerVersion, } from "aws-cdk-lib/aws-lambda";
+import { Duration as CdkDuration, RemovalPolicy, CustomResource, Fn, } 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 { SsrSite, } from "./SsrSite.js";
 import { toCdkSize } from "./util/size.js";
-import { Effect, Policy, PolicyStatement } from "aws-cdk-lib/aws-iam";
+import { PolicyStatement } from "aws-cdk-lib/aws-iam";
 import { RetentionDays } from "aws-cdk-lib/aws-logs";
 import { VisibleError } from "../error.js";
-import { Asset } from "aws-cdk-lib/aws-s3-assets";
-import { useFunctions } from "./Function.js";
-import { useDeferredTasks } from "./deferred_task.js";
 import { Logger } from "../logger.js";
-const LAYER_VERSION = "2";
-const DEFAULT_OPEN_NEXT_VERSION = "2.3.8";
-const DEFAULT_CACHE_POLICY_ALLOWED_HEADERS = [
-    "accept",
-    "rsc",
-    "next-router-prefetch",
-    "next-router-state-tree",
-    "next-url",
-    "x-prerender-bypass",
-    "x-prerender-revalidate",
-];
+const DEFAULT_OPEN_NEXT_VERSION = "3.0.2";
 /**
  * The `NextjsSite` construct is a higher level CDK construct that makes it easy to create a Next.js app.
  * @example
@@ -48,118 +33,135 @@ export class NextjsSite extends SsrSite {
     appPathsManifest;
     pagesManifest;
     prerenderManifest;
-    constructor(scope, id, rawProps) {
-        const props = {
-            logging: rawProps?.logging ?? "per-route",
-            experimental: {
-                streaming: rawProps?.experimental?.streaming ?? false,
-                disableDynamoDBCache: rawProps?.experimental?.disableDynamoDBCache ?? false,
-                disableIncrementalCache: rawProps?.experimental?.disableIncrementalCache ?? false,
-                ...rawProps?.experimental,
-            },
-            ...rawProps,
-        };
+    openNextOutput;
+    constructor(scope, id, props = {}) {
         super(scope, id, {
             buildCommand: [
                 "npx",
                 "--yes",
                 `open-next@${props?.openNextVersion ?? DEFAULT_OPEN_NEXT_VERSION}`,
                 "build",
-                ...(props.openNext?.buildOutputPath
-                    ? ["--build-output-path", props.openNext.buildOutputPath]
-                    : []),
-                ...(props.experimental.streaming ? ["--streaming"] : []),
-                ...(props.experimental.disableDynamoDBCache
-                    ? ["--dangerously-disable-dynamodb-cache"]
-                    : []),
-                ...(props.experimental.disableIncrementalCache
-                    ? ["--dangerously-disable-incremental-cache"]
-                    : []),
             ].join(" "),
             ...props,
         });
+        const disableIncrementalCache = this.openNextOutput?.additionalProps?.disableIncrementalCache ?? false;
+        const disableTagCache = this.openNextOutput?.additionalProps?.disableTagCache ?? false;
         this.handleMissingSourcemap();
-        if (this.isPerRouteLoggingEnabled()) {
-            //this.disableDefaultLogging();
-            this.uploadSourcemaps();
+        if (this.openNextOutput?.edgeFunctions?.middleware) {
+            this.setMiddlewareEnv();
         }
-        if (!props.experimental.disableIncrementalCache) {
+        if (!disableIncrementalCache) {
             this.createRevalidationQueue();
-            if (!props.experimental.disableDynamoDBCache) {
+            if (!disableTagCache) {
                 this.createRevalidationTable();
             }
         }
     }
-    static buildDefaultServerCachePolicyProps() {
-        return super.buildDefaultServerCachePolicyProps(DEFAULT_CACHE_POLICY_ALLOWED_HEADERS);
+    createFunctionOrigin(fn, key, bucket) {
+        const { path: sitePath, environment, cdk } = this.props;
+        const baseServerConfig = {
+            description: "Next.js Server",
+            environment: {
+                CACHE_BUCKET_NAME: bucket.bucketName,
+                CACHE_BUCKET_KEY_PREFIX: "_cache",
+                CACHE_BUCKET_REGION: Stack.of(this).region,
+            },
+        };
+        return {
+            type: "function",
+            constructId: `${key}ServerFunction`,
+            function: {
+                ...baseServerConfig,
+                handler: fn.handler,
+                bundle: path.join(sitePath, fn.bundle),
+                runtime: "nodejs18.x",
+                architecture: Architecture.ARM_64,
+                memorySize: 1536,
+                environment: {
+                    ...environment,
+                    ...baseServerConfig.environment,
+                },
+            },
+            streaming: fn.streaming,
+            injections: [],
+        };
+    }
+    createEcsOrigin(ecs, key, bucket) {
+        throw new Error("Ecs origin are not supported yet");
     }
-    plan(bucket) {
-        const { path: sitePath, edge, experimental, imageOptimization, cdk, } = this.props;
-        const stack = Stack.of(this);
-        const serverConfig = {
-            description: "Next.js server",
-            bundle: path.join(sitePath, ".open-next", "server-function"),
-            handler: "index.handler",
+    createEdgeOrigin(fn, key, bucket) {
+        const { path: sitePath, cdk, environment } = this.props;
+        const baseServerConfig = {
             environment: {
                 CACHE_BUCKET_NAME: bucket.bucketName,
                 CACHE_BUCKET_KEY_PREFIX: "_cache",
                 CACHE_BUCKET_REGION: Stack.of(this).region,
             },
-            layers: this.isPerRouteLoggingEnabled()
-                ? [
-                    LayerVersion.fromLayerVersionArn(this, "SSTExtension", cdk?.server?.architecture?.name === Architecture.X86_64.name
-                        ? `arn:aws:lambda:${stack.region}:226609089145:layer:sst-extension-amd64:${LAYER_VERSION}`
-                        : `arn:aws:lambda:${stack.region}:226609089145:layer:sst-extension-arm64:${LAYER_VERSION}`),
-                ]
-                : undefined,
         };
-        this.removeSourcemaps();
+        return {
+            constructId: `${key}EdgeFunction`,
+            function: {
+                handler: fn.handler,
+                bundle: path.join(sitePath, fn.bundle),
+                runtime: "nodejs18.x",
+                memorySize: 1024,
+                environment: {
+                    ...environment,
+                    ...baseServerConfig.environment,
+                },
+            },
+        };
+    }
+    plan(bucket) {
+        const { path: sitePath } = this.props;
+        const imageOptimization = this.props.imageOptimization;
+        const openNextOutputPath = path.join(sitePath ?? ".", ".open-next", "open-next.output.json");
+        if (!fs.existsSync(openNextOutputPath)) {
+            throw new VisibleError(`Failed to load ".open-next/output.json" for the "${this.id}" site.`);
+        }
+        const openNextOutput = JSON.parse(fs.readFileSync(openNextOutputPath).toString());
+        this.openNextOutput = openNextOutput;
+        const imageOpt = openNextOutput.origins
+            .imageOptimizer;
+        const defaultOrigin = openNextOutput.origins.default;
+        const remainingOrigins = Object.entries(openNextOutput.origins).filter(([key, value]) => {
+            const result = key !== "imageOptimizer" && key !== "default" && key !== "s3";
+            return result;
+        });
+        const edgeFunctions = Object.entries(openNextOutput.edgeFunctions).reduce((acc, [key, value]) => {
+            return { ...acc, [key]: this.createEdgeOrigin(value, key, bucket) };
+        }, {});
         return this.validatePlan({
-            edge: edge ?? false,
+            edge: false,
             cloudFrontFunctions: {
                 serverCfFunction: {
                     constructId: "CloudFrontFunction",
                     injections: [
                         this.useCloudFrontFunctionHostHeaderInjection(),
-                        this.useCloudFrontFunctionPrerenderBypassHeaderInjection(),
+                        this.useCloudFrontFunctionCacheHeaderKey(),
+                        this.useCloudfrontGeoHeadersInjection(),
                     ],
                 },
             },
-            edgeFunctions: edge
-                ? {
-                    edgeServer: {
-                        constructId: "ServerFunction",
-                        function: serverConfig,
-                    },
-                }
-                : undefined,
+            edgeFunctions,
             origins: {
-                ...(edge
-                    ? {}
-                    : {
-                        regionalServer: {
-                            type: "function",
-                            constructId: "ServerFunction",
-                            function: serverConfig,
-                            streaming: experimental?.streaming,
-                            injections: this.isPerRouteLoggingEnabled()
-                                ? [this.useServerFunctionPerRouteLoggingInjection()]
-                                : [],
-                        },
-                    }),
+                s3: openNextOutput.origins.s3,
                 imageOptimizer: {
                     type: "image-optimization-function",
-                    constructId: "ImageFunction",
                     function: {
-                        description: "Next.js image optimizer",
-                        handler: "index.handler",
-                        code: Code.fromAsset(path.join(sitePath, ".open-next/image-optimization-function")),
+                        description: "Next.js Image Optimization Function",
+                        handler: imageOpt.handler,
+                        code: Code.fromAsset(path.join(sitePath, imageOpt.bundle)),
                         runtime: Runtime.NODEJS_18_X,
                         architecture: Architecture.ARM_64,
                         environment: {
                             BUCKET_NAME: bucket.bucketName,
                             BUCKET_KEY_PREFIX: "_assets",
+                            ...(this.props.imageOptimization?.staticImageOptimization
+                                ? { OPENNEXT_STATIC_ETAG: "true" }
+                                : {}),
                         },
+                        permissions: ["s3"],
                         memorySize: imageOptimization?.memorySize
                             ? typeof imageOptimization.memorySize === "string"
                                 ? toCdkSize(imageOptimization.memorySize).toMebibytes()
@@ -167,98 +169,55 @@ export class NextjsSite extends SsrSite {
                             : 1536,
                     },
                 },
-                s3: {
-                    type: "s3",
-                    originPath: "_assets",
-                    copy: [
-                        {
-                            from: ".open-next/assets",
-                            to: "_assets",
-                            cached: true,
-                            versionedSubDir: "_next",
-                        },
-                        { from: ".open-next/cache", to: "_cache", cached: false },
-                    ],
-                },
+                default: defaultOrigin.type === "ecs"
+                    ? this.createEcsOrigin(defaultOrigin, "default", bucket)
+                    : this.createFunctionOrigin(defaultOrigin, "default", bucket),
+                ...Object.fromEntries(remainingOrigins.map(([key, value]) => [
+                    key,
+                    value.type === "ecs"
+                        ? this.createEcsOrigin(value, key, bucket)
+                        : this.createFunctionOrigin(value, key, bucket),
+                ])),
             },
-            behaviors: [
-                ...(edge
-                    ? [
-                        {
-                            cacheType: "server",
-                            cfFunction: "serverCfFunction",
-                            edgeFunction: "edgeServer",
-                            origin: "s3",
-                        },
-                        {
-                            cacheType: "server",
-                            pattern: this.prefixPattern("api/*"),
-                            cfFunction: "serverCfFunction",
-                            edgeFunction: "edgeServer",
-                            origin: "s3",
-                        },
-                        {
-                            cacheType: "server",
-                            pattern: this.prefixPattern("_next/data/*"),
-                            cfFunction: "serverCfFunction",
-                            edgeFunction: "edgeServer",
-                            origin: "s3",
-                        },
-                    ]
-                    : [
-                        {
-                            cacheType: "server",
-                            cfFunction: "serverCfFunction",
-                            origin: "regionalServer",
-                        },
-                        {
-                            cacheType: "server",
-                            pattern: this.prefixPattern("api/*"),
-                            cfFunction: "serverCfFunction",
-                            origin: "regionalServer",
-                        },
-                        {
-                            cacheType: "server",
-                            pattern: this.prefixPattern("_next/data/*"),
-                            cfFunction: "serverCfFunction",
-                            origin: "regionalServer",
-                        },
-                    ]),
-                {
-                    cacheType: "server",
-                    pattern: this.prefixPattern("_next/image*"),
+            behaviors: openNextOutput.behaviors.map((behavior) => {
+                return {
+                    pattern: behavior.pattern === "*" ? undefined : behavior.pattern,
+                    origin: behavior.origin,
+                    cacheType: behavior.origin === "s3" ? "static" : "server",
                     cfFunction: "serverCfFunction",
-                    origin: "imageOptimizer",
-                },
-                // create 1 behaviour for each top level asset file/folder
-                ...fs.readdirSync(path.join(sitePath, ".open-next/assets")).map((item) => ({
-                    cacheType: "static",
-                    pattern: this.prefixPattern(fs
-                        .statSync(path.join(sitePath, ".open-next/assets", item))
-                        .isDirectory()
-                        ? `${item}/*`
-                        : item),
-                    origin: "s3",
-                })),
-            ],
+                    edgeFunction: behavior.edgeFunction ?? "",
+                };
+            }),
+            buildId: this.getBuildId(),
+            warmer: openNextOutput.additionalProps?.warmer
+                ? {
+                    function: path.join(sitePath, openNextOutput.additionalProps.warmer.bundle),
+                }
+                : undefined,
             serverCachePolicy: {
-                allowedHeaders: DEFAULT_CACHE_POLICY_ALLOWED_HEADERS,
+                allowedHeaders: ["x-open-next-cache-key"],
             },
-            buildId: this.getBuildId(),
         });
     }
-    prefixPattern(pattern) {
-        // Prefix CloudFront distribution behavior path patterns with `basePath` if configured
-        const { basePath } = this.useRoutesManifest();
-        return basePath && basePath.length > 0
-            ? `${basePath.slice(1)}/${pattern}`
-            : pattern;
+    setMiddlewareEnv() {
+        const origins = this.serverFunctions.reduce((acc, server) => {
+            return {
+                ...acc,
+                [server.function
+                    ? server.id.replace("ServerFunction", "")
+                    : server.id.replace("ServerContainer", "")]: {
+                    host: Fn.parseDomainName(server.url ?? ""),
+                    port: 443,
+                    protocol: "https",
+                },
+            };
+        }, {});
+        this.edgeFunctions?.middleware?.addEnvironment("OPEN_NEXT_ORIGIN", Fn.toJsonString(origins));
     }
     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),
@@ -272,16 +231,17 @@ export class NextjsSite extends SsrSite {
             ...cdk?.revalidation,
         });
         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);
+        this.serverFunctions.forEach((server) => {
+            // 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;
         const table = new Table(this, "RevalidationTable", {
             partitionKey: { name: "tag", type: AttributeType.STRING },
             sortKey: { name: "path", type: AttributeType.STRING },
@@ -296,8 +256,10 @@ export class NextjsSite extends SsrSite {
             ],
             removalPolicy: RemovalPolicy.DESTROY,
         });
-        server?.addEnvironment("CACHE_DYNAMO_TABLE", table.tableName);
-        table.grantReadWriteData(server.role);
+        this.serverFunctions.forEach((server) => {
+            server?.addEnvironment("CACHE_DYNAMO_TABLE", table.tableName);
+            table.grantReadWriteData(server.role);
+        });
         const dynamodbProviderPath = path.join(sitePath, ".open-next", "dynamodb-provider");
         if (fs.existsSync(dynamodbProviderPath)) {
             // Provision 128MB of memory for every 4,000 prerendered routes,
@@ -338,35 +300,11 @@ export class NextjsSite extends SsrSite {
         }
     }
     getConstructMetadata() {
-        const metadata = this.getConstructMetadataBase();
         return {
-            ...metadata,
             type: "NextjsSite",
-            data: {
-                ...metadata.data,
-                routes: this.isPerRouteLoggingEnabled()
-                    ? {
-                        logGroupPrefix: `/sst/lambda/${this.serverFunction.functionName}`,
-                        data: this.useRoutes().map(({ route, logGroupPath }) => ({
-                            route,
-                            logGroupPath,
-                        })),
-                    }
-                    : undefined,
-            },
+            ...this.getConstructMetadataBase(),
         };
     }
-    removeSourcemaps() {
-        const { path: sitePath } = this.props;
-        const files = globSync("**/*.js.map", {
-            cwd: path.join(sitePath, ".open-next", "server-function"),
-            nodir: true,
-            dot: true,
-        });
-        for (const file of files) {
-            fs.rmSync(path.join(sitePath, ".open-next", "server-function", file));
-        }
-    }
     useRoutes() {
         if (this._routes)
             return this._routes;
@@ -510,38 +448,57 @@ export class NextjsSite extends SsrSite {
             Logger.debug("Failed to load prerender-manifest.json", e);
         }
     }
-    useServerFunctionPerRouteLoggingInjection() {
+    // This function is used to improve cache hit ratio by setting the cache key based on the request headers and the path
+    // next/image only need the accept header, and this header is not useful for the rest of the query
+    useCloudFrontFunctionCacheHeaderKey() {
         return `
-if (event.rawPath) {
-  const routeData = ${JSON.stringify(
-        // @ts-expect-error
-        this.useRoutes().map(({ regexMatch, prefixMatch, logGroupPath }) => ({
-            regex: regexMatch,
-            prefix: prefixMatch,
-            logGroupPath,
-        })))}.find(({ regex, prefix }) => {
-    if (regex) return event.rawPath.match(new RegExp(regex));
-    if (prefix) return event.rawPath === prefix || (event.rawPath === prefix + "/");
-    return false;
-  });
-  if (routeData) {
-    console.log("::sst::" + JSON.stringify({
-      action:"log.split",
-      properties: {
-        logGroupName:"/sst/lambda/" + context.functionName + routeData.logGroupPath,
-      },
-    }));
+function getHeader(key) {
+  var header = request.headers[key];
+  if(header) {
+      if(header.multiValue){
+          return header.multiValue.map((header) => header.value).join(",");
+      }
+      if(header.value){
+          return header.value;
+      }
+  }
+  return ""
+  }
+  var cacheKey = "";
+  if(request.uri.startsWith("/_next/image")) {
+    cacheKey = getHeader("accept");
+  }else {
+    cacheKey = getHeader("rsc") + getHeader("next-router-prefetch") + getHeader("next-router-state-tree") + getHeader("next-url") + getHeader("x-prerender-revalidate");
+  }
+  if(request.cookies["__prerender_bypass"]) {
+    cacheKey += request.cookies["__prerender_bypass"] ? request.cookies["__prerender_bypass"].value : "";
   }
-}`;
+  var crypto = require('crypto');
+  
+  var hashedKey = crypto.createHash('md5').update(cacheKey).digest('hex');
+  request.headers["x-open-next-cache-key"] = {value: hashedKey};
+  `;
     }
-    useCloudFrontFunctionPrerenderBypassHeaderInjection() {
-        // In Next.js page router preview mode (depends on the cookie __prerender_bypass),
-        // to ensure we receive the cached page instead of the preview version, we set the
-        // header "x-prerender-bypass", and add it to cache policy's allowed headers.
+    // Inject the CloudFront viewer country, region, latitude, and longitude headers into the request headers
+    // for OpenNext to use them
+    useCloudfrontGeoHeadersInjection() {
         return `
-if (request.cookies["__prerender_bypass"]) { 
-  request.headers["x-prerender-bypass"] = { value: "true" }; 
-}`;
+if(request.headers["cloudfront-viewer-city"]) {
+  request.headers["x-open-next-city"] = request.headers["cloudfront-viewer-city"];
+}
+if(request.headers["cloudfront-viewer-country"]) {
+  request.headers["x-open-next-country"] = request.headers["cloudfront-viewer-country"];
+}
+if(request.headers["cloudfront-viewer-region"]) {
+  request.headers["x-open-next-region"] = request.headers["cloudfront-viewer-region"];
+}
+if(request.headers["cloudfront-viewer-latitude"]) {
+  request.headers["x-open-next-latitude"] = request.headers["cloudfront-viewer-latitude"];
+}
+if(request.headers["cloudfront-viewer-longitude"]) {
+  request.headers["x-open-next-longitude"] = request.headers["cloudfront-viewer-longitude"];
+}
+    `;
     }
     getBuildId() {
         const { path: sitePath } = this.props;
@@ -605,11 +562,6 @@ if (request.cookies["__prerender_bypass"]) {
             return;
         return sourcemapPath;
     }
-    isPerRouteLoggingEnabled() {
-        return (!this.doNotDeploy &&
-            !this.props.edge &&
-            this.props.logging === "per-route");
-    }
     handleMissingSourcemap() {
         if (this.doNotDeploy || this.props.edge)
             return;
@@ -618,48 +570,6 @@ if (request.cookies["__prerender_bypass"]) {
             return;
         this.serverFunction._overrideMissingSourcemap();
     }
-    disableDefaultLogging() {
-        const stack = Stack.of(this);
-        const server = this.serverFunction;
-        const policy = new Policy(this, "DisableLoggingPolicy", {
-            statements: [
-                new PolicyStatement({
-                    effect: Effect.DENY,
-                    actions: [
-                        "logs:CreateLogGroup",
-                        "logs:CreateLogStream",
-                        "logs:PutLogEvents",
-                    ],
-                    resources: [
-                        `arn:aws:logs:${stack.region}:${stack.account}:log-group:/aws/lambda/${server.functionName}`,
-                        `arn:aws:logs:${stack.region}:${stack.account}:log-group:/aws/lambda/${server.functionName}:*`,
-                    ],
-                }),
-            ],
-        });
-        server.role?.attachInlinePolicy(policy);
-    }
-    uploadSourcemaps() {
-        const stack = Stack.of(this);
-        const server = this.serverFunction;
-        this.useRoutes().forEach(({ sourcemapPath, sourcemapKey }) => {
-            if (!sourcemapPath || !sourcemapKey)
-                return;
-            useDeferredTasks().add(async () => {
-                // zip sourcemap
-                const zipPath = `${sourcemapPath}.gz.zip`;
-                const data = await fs.promises.readFile(sourcemapPath);
-                await fs.promises.writeFile(zipPath, zlib.gzipSync(data));
-                const asset = new Asset(this, `Sourcemap-${sourcemapKey}`, {
-                    path: zipPath,
-                });
-                useFunctions().sourcemaps.add(stack.stackName, {
-                    asset,
-                    tarKey: path.join(server.functionArn, sourcemapKey),
-                });
-            });
-        });
-    }
     static buildCloudWatchRouteName(route) {
         return route.replace(/[^a-zA-Z0-9_\-/.#]/g, "");
     }

package/constructs/RemixSite.d.ts

@@ -90,6 +90,9 @@ export declare class RemixSite extends SsrSite {
             allowedHeaders?: string[] | undefined;
         } | undefined;
         buildId?: string | undefined;
+        warmer?: {
+            function: string;
+        } | undefined;
     };
     private hasViteConfig;
     private getServerModuleFormat;

package/constructs/SolidStartSite.d.ts

@@ -72,6 +72,9 @@ export declare class SolidStartSite extends SsrSite {
             allowedHeaders?: string[] | undefined;
         } | undefined;
         buildId?: string | undefined;
+        warmer?: {
+            function: string;
+        } | undefined;
     };
     getConstructMetadata(): {
         data: {

package/constructs/SsrFunction.d.ts

@@ -1,7 +1,7 @@
 import { Construct } from "constructs";
 import { IGrantable } from "aws-cdk-lib/aws-iam";
 import { RetentionDays } from "aws-cdk-lib/aws-logs";
-import { FunctionOptions, Function as CdkFunction, FunctionUrlOptions } from "aws-cdk-lib/aws-lambda";
+import { FunctionOptions, Function as CdkFunction, FunctionUrlOptions, FunctionUrl } from "aws-cdk-lib/aws-lambda";
 import { NodeJSProps, FunctionCopyFilesProps } from "./Function.js";
 import { SSTConstruct } from "./Construct.js";
 import { BindingResource } from "./util/binding.js";
@@ -29,6 +29,7 @@ export declare class SsrFunction extends Construct implements SSTConstruct {
     /** @internal */
     readonly _doNotAllowOthersToBind = true;
     function: CdkFunction;
+    private functionUrl?;
     private assetReplacer;
     private assetReplacerPolicy;
     private missingSourcemap?;
@@ -37,8 +38,9 @@ export declare class SsrFunction extends Construct implements SSTConstruct {
     get role(): import("aws-cdk-lib/aws-iam").IRole | undefined;
     get functionArn(): string;
     get functionName(): string;
+    get url(): string | undefined;
     addEnvironment(key: string, value: string): CdkFunction;
-    addFunctionUrl(props?: FunctionUrlOptions): import("aws-cdk-lib/aws-lambda").FunctionUrl;
+    addFunctionUrl(props?: FunctionUrlOptions): FunctionUrl;
     grantInvoke(grantee: IGrantable): import("aws-cdk-lib/aws-iam").Grant;
     attachPermissions(permissions: Permissions): void;
     _overrideMissingSourcemap(): void;