Use Lambda URL as CloudFront origin

.eslintignore

@@ -2,4 +2,5 @@
 /lib
 /dist
 /utils
+/src/utils/GetWebLambdaFunctions.ts
 /test/fixtures

src/constructs/aws/ServerSideWebsite.ts

@@ -37,6 +37,7 @@ const SCHEMA = {
     properties: {
         type: { const: "server-side-website" },
         apiGateway: { enum: ["http", "rest"] },
+        originName: { type: "string" },
         assets: {
             type: "object",
             additionalProperties: { type: "string" },
@@ -115,12 +116,6 @@ export class ServerSideWebsite extends AwsConstruct {
         })();
         const backendCachePolicy = CachePolicy.CACHING_DISABLED;
 
-        const apiId =
-            configuration.apiGateway === "rest"
-                ? this.provider.naming.getRestApiLogicalId()
-                : this.provider.naming.getHttpApiLogicalId();
-        const apiGatewayDomain = Fn.join(".", [Fn.ref(apiId), `execute-api.${this.provider.region}.amazonaws.com`]);
-
         // Cast the domains to an array
         this.domains = configuration.domain !== undefined ? flatten([configuration.domain]) : undefined;
         const certificate =
@@ -132,7 +127,7 @@ export class ServerSideWebsite extends AwsConstruct {
             comment: `${provider.stackName} ${id} website CDN`,
             defaultBehavior: {
                 // Origins are where CloudFront fetches content
-                origin: new HttpOrigin(apiGatewayDomain, {
+                origin: new HttpOrigin(this.getCloudFrontOrigin(), {
                     // API Gateway only supports HTTPS
                     protocolPolicy: OriginProtocolPolicy.HTTPS_ONLY,
                 }),
@@ -435,4 +430,57 @@ export class ServerSideWebsite extends AwsConstruct {
     private getErrorPageFileName(): string {
         return this.configuration.errorPage !== undefined ? path.basename(this.configuration.errorPage) : "";
     }
+
+    private getCloudFrontOrigin(): string {
+        const functions = this.provider.getWebLambdaFunctions();
+        const functionsUsingLambdaUrl = functions.reduce((count, func) => count + (func.usesLambdaUrl ? 1 : 0), 0);
+
+        // Fail if no web functions defined
+        if (functions.length === 0) {
+            throw new ServerlessError(
+                "Error trying to detect CloudFront origin. Please check that at least one Lambda function uses 'url', 'events.httpApi', 'events.http' or 'events.alb'.",
+                "LIFT_INVALID_STACK_CONFIGURATION"
+            );
+        }
+
+        // Try to use ApiGateway if one or more functions are defined and none uses Lambda URL
+        if (functions.length >= 1 && functionsUsingLambdaUrl === 0) {
+            return this.getApiGatewayUrl();
+        }
+
+        // Try to use Lambda URL if only one web function is defined
+        if (functions.length === 1 && functionsUsingLambdaUrl === 1) {
+            return this.getLambdaUrl(functions[0].name);
+        }
+
+        // Try to use configured origin
+        if (this.configuration.originName !== undefined) {
+            const selectedWebFunction = functions.find((f) => f.name === this.configuration.originName);
+            if (selectedWebFunction) {
+                return selectedWebFunction.usesLambdaUrl
+                    ? this.getLambdaUrl(selectedWebFunction.name)
+                    : this.getApiGatewayUrl();
+            }
+        }
+
+        throw new ServerlessError(
+            `Error trying to detect CloudFront origin. Invalid or missing 'constructs.${this.id}.originName' key.`,
+            "LIFT_INVALID_CONSTRUCT_CONFIGURATION"
+        );
+    }
+
+    private getApiGatewayUrl() {
+        const apiId =
+            this.configuration.apiGateway === "rest"
+                ? this.provider.naming.getRestApiLogicalId()
+                : this.provider.naming.getHttpApiLogicalId();
+
+        return Fn.join(".", [Fn.ref(apiId), `execute-api.${this.provider.region}.amazonaws.com`]);
+    }
+
+    private getLambdaUrl(name: string) {
+        const lambdaUrlId = this.provider.naming.getLambdaFunctionUrlLogicalId(name);
+
+        return Fn.select(2, Fn.split("/", Fn.getAtt(lambdaUrlId, "FunctionUrl").toString()));
+    }
 }

src/interfaces/WebLambdaFunctionInterface.ts

@@ -0,0 +1,4 @@
+export interface WebLambdaFunctionInterface {
+    name: string;
+    usesLambdaUrl: boolean;
+}

src/providers/AwsProvider.ts

@@ -18,6 +18,8 @@ import { getStackOutput } from "../CloudFormation";
 import type { CloudformationTemplate, Provider as LegacyAwsProvider, Serverless } from "../types/serverless";
 import { awsRequest } from "../classes/aws";
 import ServerlessError from "../utils/error";
+import type { WebLambdaFunctionInterface } from "../interfaces/WebLambdaFunctionInterface";
+import { GetWebLambdaFunctions } from "../utils/GetWebLambdaFunctions";
 
 const AWS_DEFINITION = {
     type: "object",
@@ -62,6 +64,7 @@ export class AwsProvider implements ProviderInterface {
     public naming: {
         getStackName: () => string;
         getLambdaLogicalId: (functionName: string) => string;
+        getLambdaFunctionUrlLogicalId: (functionName: string) => string;
         getRestApiLogicalId: () => string;
         getHttpApiLogicalId: () => string;
     };
@@ -160,6 +163,18 @@ export class AwsProvider implements ProviderInterface {
             resources: this.app.synth().getStackByName(this.stack.stackName).template as CloudformationTemplate,
         });
     }
+
+    /**
+     * This function can be used by other constructs to get all web Lambda functions
+     * Web Lambda functions must contain at least one of the following keys:
+     * - url
+     * - events.http
+     * - events.httpApi
+     * - events.alb
+     */
+    getWebLambdaFunctions(): WebLambdaFunctionInterface[] {
+        return GetWebLambdaFunctions(this.serverless.service.functions);
+    }
 }
 
 /**

src/types/serverless.ts

@@ -24,6 +24,7 @@ export type Provider = {
     naming: {
         getStackName: () => string;
         getLambdaLogicalId: (functionName: string) => string;
+        getLambdaFunctionUrlLogicalId: (functionName: string) => string;
         getRestApiLogicalId: () => string;
         getHttpApiLogicalId: () => string;
         getCompiledTemplateFileName: () => string;

src/utils/GetWebLambdaFunctions.ts

@@ -0,0 +1,21 @@
+import { WebLambdaFunctionInterface } from "../interfaces/WebLambdaFunctionInterface";
+
+export function GetWebLambdaFunctions(functions: any): WebLambdaFunctionInterface[] {
+    if (functions === undefined) {
+        return [];
+    }
+
+    return Object.keys(functions)
+        .filter((key) => {
+            const fn = functions[key];
+
+            return fn.url !== undefined || (fn.events !== undefined && fn.events.some((e: any) => e.httpApi || e.http || e.alb));
+        })
+        .map((key) => {
+            return {
+                name: key,
+                usesLambdaUrl: functions[key].url !== undefined,
+            };
+        })
+    ;
+}