cdk-nextjs 0.6.2 → 0.7.1

package/lib/nextjs-compute/nextjs-functions.js

@@ -3,99 +3,145 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.NextjsFunctions = void 0;
 const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
 const node_fs_1 = require("node:fs");
-const node_path_1 = require("node:path");
-const posix_1 = require("node:path/posix");
 const aws_cdk_lib_1 = require("aws-cdk-lib");
-const aws_iam_1 = require("aws-cdk-lib/aws-iam");
 const aws_lambda_1 = require("aws-cdk-lib/aws-lambda");
 const constructs_1 = require("constructs");
+const nextjs_compute_base_props_1 = require("./nextjs-compute-base-props");
+const function_groups_1 = require("../adapter/function-groups");
 const constants_1 = require("../constants");
+const manifest_1 = require("../runtime/manifest");
 const get_architecture_1 = require("../utils/get-architecture");
+const zip_directory_1 = require("../utils/zip-directory");
 /**
  * Run Next.js in functions on AWS with AWS Lambda.
+ *
+ * A plain zip function on the Node.js managed runtime: the deployment root
+ * `NextjsBuild` staged is the asset, and cdk-nextjs's own bundled shell
+ * (`cdk-nextjs-runtime/lambda.mjs`) is the handler. It invokes the entrypoints
+ * `next build` produced in-process, so there is no Next.js HTTP server, no
+ * Docker image, and no Lambda Web Adapter — response streaming comes from
+ * `awslambda.streamifyResponse` directly.
  */
 class NextjsFunctions extends constructs_1.Construct {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk-nextjs.NextjsFunctions", version: "0.6.2" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk-nextjs.NextjsFunctions", version: "0.7.1" };
+    /**
+     * The `default` group's function: the one the distribution's default behavior
+     * targets, and the only one at all unless `functionGroups` is used.
+     *
+     * A zip-packaged `lambda.Function` since 0.7.0; before that it was a
+     * `DockerImageFunction`. Code that relied on the image-specific type (its
+     * repository, or `DockerImageCode`) has to change.
+     */
     function;
+    /** The `default` group's Function URL. Only for `GLOBAL_FUNCTIONS`. */
     functionUrl;
+    /**
+     * Every deployed group, `default` first. Iterate this rather than
+     * {@link function} for anything that must reach all of them — IAM grants and
+     * CloudFront behaviors both do.
+     */
+    functionGroups;
     props;
     constructor(scope, id, props) {
         super(scope, id);
         this.props = props;
-        this.function = this.createFunction();
-        if (props.nextjsType === constants_1.NextjsType.GLOBAL_FUNCTIONS) {
-            this.function.grantInvoke(new aws_iam_1.ServicePrincipal("cloudfront.amazonaws.com"));
-            this.functionUrl = this.function.addFunctionUrl({
-                authType: aws_lambda_1.FunctionUrlAuthType.AWS_IAM,
-                invokeMode: aws_lambda_1.InvokeMode.RESPONSE_STREAM,
-                ...this.props.overrides?.functionUrlProps,
-            });
+        const roots = props.deploymentRoots;
+        this.functionGroups = roots.map((root) => {
+            const group = props.functionGroups?.find((it) => it.name === root.name);
+            // The default group keeps the unsuffixed construct id it has always had,
+            // so adding `functionGroups` to a deployed app does not replace the
+            // function that was already serving everything.
+            const fn = this.createFunction(root.name === function_groups_1.DEFAULT_FUNCTION_GROUP
+                ? "Functions"
+                : `Functions-${root.name}`, root, group?.overrides);
+            let functionUrl;
+            if (props.nextjsType === constants_1.NextjsType.GLOBAL_FUNCTIONS) {
+                functionUrl = fn.addFunctionUrl({
+                    authType: aws_lambda_1.FunctionUrlAuthType.AWS_IAM,
+                    invokeMode: aws_lambda_1.InvokeMode.RESPONSE_STREAM,
+                    ...props.overrides?.functionUrlProps,
+                    ...group?.overrides?.functionUrlProps,
+                });
+            }
+            return {
+                name: root.name,
+                routes: root.routes,
+                function: fn,
+                functionUrl,
+            };
+        });
+        const defaultGroup = this.functionGroups.find((group) => group.name === function_groups_1.DEFAULT_FUNCTION_GROUP);
+        if (!defaultGroup) {
+            throw new Error(`Expected a "${function_groups_1.DEFAULT_FUNCTION_GROUP}" deployment root, got ` +
+                `[${roots.map((root) => root.name).join(", ")}].`);
         }
+        this.function = defaultGroup.function;
+        this.functionUrl = defaultGroup.functionUrl;
     }
-    createFunction() {
-        // Create DockerImageCode from local build output or use provided dockerImageCode
-        const dockerImageCode = this.createDockerImageCode();
+    createFunction(id, root, groupOverrides) {
+        const architecture = this.props.architecture ?? (0, get_architecture_1.getLambdaArchitecture)();
+        const requested = groupOverrides?.functionProps?.architecture ??
+            this.props.overrides?.functionProps?.architecture;
+        if (requested && requested.name !== architecture.name) {
+            // Ignoring it would deploy a function the user didn't ask for; honoring
+            // it would deploy one that can't load the `sharp` binaries staged for
+            // the root. The root constructs pass the same value to both unless a
+            // group's own override asks for another (one architecture per
+            // deployment), or `NextjsBuild` and `NextjsFunctions` are wired by hand.
+            throw new Error(`${constants_1.LOG_PREFIX} functionProps.architecture for function group "${root.name}" is ${requested.name}, ` +
+                `but NextjsBuild staged its native dependencies (sharp) for ${architecture.name}. ` +
+                "Every function group deploys one architecture: set it construct-wide in " +
+                "`overrides.nextjsFunctions.functionProps` or, wiring the constructs yourself, pass " +
+                "NextjsBuild's `architecture` to NextjsFunctions.");
+        }
+        // Zipped here rather than by `cdk-assets`, which would dereference the
+        // pnpm symlinks the root depends on; see `zipDirectory`.
+        const zipPath = `${root.path}.zip`;
+        (0, node_fs_1.writeFileSync)(zipPath, (0, zip_directory_1.zipDirectory)(root.path));
         const functionProps = {
-            architecture: (0, get_architecture_1.getLambdaArchitecture)(),
-            code: dockerImageCode,
+            code: aws_lambda_1.Code.fromAsset(zipPath),
+            handler: `${manifest_1.RUNTIME_DIR_NAME}/lambda.handler`,
             memorySize: 2048,
+            runtime: new aws_lambda_1.Runtime("nodejs24.x", aws_lambda_1.RuntimeFamily.NODEJS),
             timeout: aws_cdk_lib_1.Duration.seconds(30),
-            ...this.props.overrides?.dockerImageFunctionProps,
+            ...this.sharedFunctionProps(root.name),
+            ...groupOverrides?.functionProps,
+            // After the overrides: the function must run what `NextjsBuild` staged.
+            // An override that disagrees throws above rather than being dropped here.
+            architecture,
             environment: {
-                AWS_LWA_ENABLE_COMPRESSION: "true",
-                AWS_LWA_INVOKE_MODE: "response_stream",
-                AWS_LWA_READINESS_CHECK_PATH: this.props.healthCheckPath,
-                AWS_LWA_READINESS_CHECK_PORT: "3000",
-                READINESS_CHECK_PATH: `http://127.0.0.1:3000${this.props.healthCheckPath}`,
-                // Cache configuration environment variables
-                CDK_NEXTJS_CACHE_BUCKET_NAME: this.props.cacheBucket.bucketName,
-                CDK_NEXTJS_REVALIDATION_TABLE_NAME: this.props.revalidationTable.tableName,
-                CDK_NEXTJS_BUILD_ID: this.props.buildId,
-                ...this.props.overrides?.dockerImageFunctionProps?.environment,
+                // What `next start` and the Containers Dockerfiles set. Externalized
+                // packages (React for Pages Router SSR among them) load their dev
+                // builds without it.
+                NODE_ENV: "production",
+                ...(0, nextjs_compute_base_props_1.runtimeEnvironment)(this.props),
+                // Which group this function is. Only used to make a misroute legible:
+                // if CloudFront sends a request here for a route that was packaged
+                // elsewhere, the 500 says which function got it and which group it
+                // belongs to, rather than surfacing as a module-not-found deep inside
+                // the Next.js server.
+                [manifest_1.FUNCTION_GROUP_ENV_VAR]: root.name,
+                ...this.props.overrides?.functionProps?.environment,
+                ...groupOverrides?.functionProps?.environment,
             },
         };
-        const fn = new aws_lambda_1.DockerImageFunction(this, "Functions", functionProps);
-        // Grant cache access permissions
-        this.props.cacheBucket.grantReadWrite(fn);
-        this.props.revalidationTable.grantReadWriteData(fn);
+        const fn = new aws_lambda_1.Function(this, id, functionProps);
+        (0, nextjs_compute_base_props_1.grantRuntimeAccess)(this.props, fn);
         return fn;
     }
-    createDockerImageCode() {
-        // Build context is the buildDirectory (where the Next.js app is located)
-        const buildContext = this.props.buildDirectory;
-        const dockerfileName = "functions.Dockerfile";
-        // Copy Dockerfile to build context to avoid path resolution issues
-        this.copyDockerfileToContext(buildContext, dockerfileName);
-        const relativeEntrypointPath = this.props.relativePathToPackage
-            ? // joinPosix b/c this will be referenced in Docker container (Linux)
-                (0, posix_1.join)(this.props.relativePathToPackage, "server.js")
-            : "server.js";
-        return aws_lambda_1.DockerImageCode.fromImageAsset(buildContext, {
-            file: dockerfileName, // Now it's just the filename in the build context
-            cmd: ["node", relativeEntrypointPath],
-            exclude: ["cdk.out"], // for common case where cdk deploy is run in same directory as nextjs app
-            buildArgs: {
-                RELATIVE_PATH_TO_PACKAGE: this.props.relativePathToPackage || ".",
-                ...this.props.overrides?.assetImageCodeProps?.buildArgs,
-            },
-            ...this.props.overrides?.assetImageCodeProps,
-        });
-    }
-    copyDockerfileToContext(buildContext, dockerfileName) {
-        const targetDockerfile = (0, node_path_1.join)(buildContext, dockerfileName);
-        // Check if Dockerfile already exists - if so, use the existing one (developer control)
-        if ((0, node_fs_1.existsSync)(targetDockerfile)) {
-            console.log(`${constants_1.LOG_PREFIX} Using existing Dockerfile: ${dockerfileName}`);
-        }
-        else {
-            const sourceDockerfile = (0, node_path_1.join)(__dirname, "..", "nextjs-build", dockerfileName);
-            if (!(0, node_fs_1.existsSync)(sourceDockerfile)) {
-                throw new Error(`Source Dockerfile not found: ${sourceDockerfile}. Ensure the cdk-nextjs package is properly built.`);
-            }
-            (0, node_fs_1.copyFileSync)(sourceDockerfile, targetDockerfile);
-            console.log(`${constants_1.LOG_PREFIX} Created ${dockerfileName} in your project directory.`);
+    /**
+     * The construct-wide `functionProps`, minus what identifies a single function
+     * when this is not the `default` group; see
+     * {@link NextjsFunctionsOverrides.functionProps}.
+     */
+    sharedFunctionProps(groupName) {
+        const shared = this.props.overrides?.functionProps;
+        if (!shared || groupName === function_groups_1.DEFAULT_FUNCTION_GROUP) {
+            return shared;
         }
+        const { functionName, code, handler, ...rest } = shared;
+        return rest;
     }
 }
 exports.NextjsFunctions = NextjsFunctions;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nextjs-functions.js","sourceRoot":"","sources":["../../src/nextjs-compute/nextjs-functions.ts"],"names":[],"mappings":"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","sourcesContent":["import { copyFileSync, existsSync } from \"node:fs\";\nimport { join as joinPath } from \"node:path\";\nimport { join as joinPosix } from \"node:path/posix\";\nimport { Duration } from \"aws-cdk-lib\";\nimport { ServicePrincipal } from \"aws-cdk-lib/aws-iam\";\nimport {\n  AssetImageCodeProps,\n  DockerImageCode,\n  DockerImageFunction,\n  DockerImageFunctionProps,\n  FunctionUrl,\n  FunctionUrlAuthType,\n  InvokeMode,\n} from \"aws-cdk-lib/aws-lambda\";\nimport { Construct } from \"constructs\";\nimport { NextjsComputeBaseProps } from \"./nextjs-compute-base-props\";\nimport { LOG_PREFIX, NextjsType } from \"../constants\";\nimport { OptionalDockerImageFunctionProps } from \"../generated-structs/OptionalDockerImageFunctionProps\";\nimport { OptionalFunctionUrlProps } from \"../generated-structs/OptionalFunctionUrlProps\";\nimport { getLambdaArchitecture } from \"../utils/get-architecture\";\n\nexport interface NextjsFunctionsOverrides {\n  readonly dockerImageFunctionProps?: OptionalDockerImageFunctionProps;\n  readonly functionUrlProps?: OptionalFunctionUrlProps;\n  readonly assetImageCodeProps?: AssetImageCodeProps;\n}\n\nexport interface NextjsFunctionsProps extends NextjsComputeBaseProps {\n  readonly overrides?: NextjsFunctionsOverrides;\n}\n\n/**\n * Run Next.js in functions on AWS with AWS Lambda.\n */\nexport class NextjsFunctions extends Construct {\n  function: DockerImageFunction;\n  functionUrl?: FunctionUrl;\n\n  private props: NextjsFunctionsProps;\n\n  constructor(scope: Construct, id: string, props: NextjsFunctionsProps) {\n    super(scope, id);\n    this.props = props;\n    this.function = this.createFunction();\n    if (props.nextjsType === NextjsType.GLOBAL_FUNCTIONS) {\n      this.function.grantInvoke(\n        new ServicePrincipal(\"cloudfront.amazonaws.com\"),\n      );\n      this.functionUrl = this.function.addFunctionUrl({\n        authType: FunctionUrlAuthType.AWS_IAM,\n        invokeMode: InvokeMode.RESPONSE_STREAM,\n        ...this.props.overrides?.functionUrlProps,\n      });\n    }\n  }\n\n  private createFunction() {\n    // Create DockerImageCode from local build output or use provided dockerImageCode\n    const dockerImageCode = this.createDockerImageCode();\n\n    const functionProps: DockerImageFunctionProps = {\n      architecture: getLambdaArchitecture(),\n      code: dockerImageCode,\n      memorySize: 2048,\n      timeout: Duration.seconds(30),\n      ...this.props.overrides?.dockerImageFunctionProps,\n      environment: {\n        AWS_LWA_ENABLE_COMPRESSION: \"true\",\n        AWS_LWA_INVOKE_MODE: \"response_stream\",\n        AWS_LWA_READINESS_CHECK_PATH: this.props.healthCheckPath,\n        AWS_LWA_READINESS_CHECK_PORT: \"3000\",\n        READINESS_CHECK_PATH: `http://127.0.0.1:3000${this.props.healthCheckPath}`,\n        // Cache configuration environment variables\n        CDK_NEXTJS_CACHE_BUCKET_NAME: this.props.cacheBucket.bucketName,\n        CDK_NEXTJS_REVALIDATION_TABLE_NAME:\n          this.props.revalidationTable.tableName,\n        CDK_NEXTJS_BUILD_ID: this.props.buildId,\n        ...this.props.overrides?.dockerImageFunctionProps?.environment,\n      },\n    };\n\n    const fn = new DockerImageFunction(this, \"Functions\", functionProps);\n\n    // Grant cache access permissions\n    this.props.cacheBucket.grantReadWrite(fn);\n    this.props.revalidationTable.grantReadWriteData(fn);\n\n    return fn;\n  }\n\n  private createDockerImageCode(): DockerImageCode {\n    // Build context is the buildDirectory (where the Next.js app is located)\n    const buildContext = this.props.buildDirectory;\n    const dockerfileName = \"functions.Dockerfile\";\n\n    // Copy Dockerfile to build context to avoid path resolution issues\n    this.copyDockerfileToContext(buildContext, dockerfileName);\n\n    const relativeEntrypointPath = this.props.relativePathToPackage\n      ? // joinPosix b/c this will be referenced in Docker container (Linux)\n        joinPosix(this.props.relativePathToPackage, \"server.js\")\n      : \"server.js\";\n\n    return DockerImageCode.fromImageAsset(buildContext, {\n      file: dockerfileName, // Now it's just the filename in the build context\n      cmd: [\"node\", relativeEntrypointPath],\n      exclude: [\"cdk.out\"], // for common case where cdk deploy is run in same directory as nextjs app\n      buildArgs: {\n        RELATIVE_PATH_TO_PACKAGE: this.props.relativePathToPackage || \".\",\n        ...this.props.overrides?.assetImageCodeProps?.buildArgs,\n      },\n      ...this.props.overrides?.assetImageCodeProps,\n    });\n  }\n\n  private copyDockerfileToContext(\n    buildContext: string,\n    dockerfileName: string,\n  ): void {\n    const targetDockerfile = joinPath(buildContext, dockerfileName);\n\n    // Check if Dockerfile already exists - if so, use the existing one (developer control)\n    if (existsSync(targetDockerfile)) {\n      console.log(`${LOG_PREFIX} Using existing Dockerfile: ${dockerfileName}`);\n    } else {\n      const sourceDockerfile = joinPath(\n        __dirname,\n        \"..\",\n        \"nextjs-build\",\n        dockerfileName,\n      );\n\n      if (!existsSync(sourceDockerfile)) {\n        throw new Error(\n          `Source Dockerfile not found: ${sourceDockerfile}. Ensure the cdk-nextjs package is properly built.`,\n        );\n      }\n\n      copyFileSync(sourceDockerfile, targetDockerfile);\n      console.log(\n        `${LOG_PREFIX} Created ${dockerfileName} in your project directory.`,\n      );\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nextjs-functions.js","sourceRoot":"","sources":["../../src/nextjs-compute/nextjs-functions.ts"],"names":[],"mappings":";;;;AAAA,qCAAwC;AACxC,6CAAuC;AACvC,uDAUgC;AAChC,2CAAuC;AACvC,2EAIqC;AACrC,gEAAoE;AACpE,4CAAsD;AAItD,kDAA+E;AAC/E,gEAAkE;AAClE,0DAAsD;AAsGtD;;;;;;;;;GASG;AACH,MAAa,eAAgB,SAAQ,sBAAS;;IAC5C;;;;;;;OAOG;IACH,QAAQ,CAAiB;IACzB,uEAAuE;IACvE,WAAW,CAAe;IAC1B;;;;OAIG;IACH,cAAc,CAAiC;IAEvC,KAAK,CAAuB;IAEpC,YAAY,KAAgB,EAAE,EAAU,EAAE,KAA2B;QACnE,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QACjB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QAEnB,MAAM,KAAK,GAAG,KAAK,CAAC,eAAe,CAAC;QACpC,IAAI,CAAC,cAAc,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE;YACvC,MAAM,KAAK,GAAG,KAAK,CAAC,cAAc,EAAE,IAAI,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,IAAI,KAAK,IAAI,CAAC,IAAI,CAAC,CAAC;YACxE,yEAAyE;YACzE,oEAAoE;YACpE,gDAAgD;YAChD,MAAM,EAAE,GAAG,IAAI,CAAC,cAAc,CAC5B,IAAI,CAAC,IAAI,KAAK,wCAAsB;gBAClC,CAAC,CAAC,WAAW;gBACb,CAAC,CAAC,aAAa,IAAI,CAAC,IAAI,EAAE,EAC5B,IAAI,EACJ,KAAK,EAAE,SAAS,CACjB,CAAC;YACF,IAAI,WAAoC,CAAC;YACzC,IAAI,KAAK,CAAC,UAAU,KAAK,sBAAU,CAAC,gBAAgB,EAAE,CAAC;gBACrD,WAAW,GAAG,EAAE,CAAC,cAAc,CAAC;oBAC9B,QAAQ,EAAE,gCAAmB,CAAC,OAAO;oBACrC,UAAU,EAAE,uBAAU,CAAC,eAAe;oBACtC,GAAG,KAAK,CAAC,SAAS,EAAE,gBAAgB;oBACpC,GAAG,KAAK,EAAE,SAAS,EAAE,gBAAgB;iBACtC,CAAC,CAAC;YACL,CAAC;YACD,OAAO;gBACL,IAAI,EAAE,IAAI,CAAC,IAAI;gBACf,MAAM,EAAE,IAAI,CAAC,MAAM;gBACnB,QAAQ,EAAE,EAAE;gBACZ,WAAW;aACZ,CAAC;QACJ,CAAC,CAAC,CAAC;QAEH,MAAM,YAAY,GAAG,IAAI,CAAC,cAAc,CAAC,IAAI,CAC3C,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,KAAK,wCAAsB,CACjD,CAAC;QACF,IAAI,CAAC,YAAY,EAAE,CAAC;YAClB,MAAM,IAAI,KAAK,CACb,eAAe,wCAAsB,yBAAyB;gBAC5D,IAAI,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CACpD,CAAC;QACJ,CAAC;QACD,IAAI,CAAC,QAAQ,GAAG,YAAY,CAAC,QAAQ,CAAC;QACtC,IAAI,CAAC,WAAW,GAAG,YAAY,CAAC,WAAW,CAAC;IAC9C,CAAC;IAEO,cAAc,CACpB,EAAU,EACV,IAA0B,EAC1B,cAAoD;QAEpD,MAAM,YAAY,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,IAAI,IAAA,wCAAqB,GAAE,CAAC;QACxE,MAAM,SAAS,GACb,cAAc,EAAE,aAAa,EAAE,YAAY;YAC3C,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,aAAa,EAAE,YAAY,CAAC;QACpD,IAAI,SAAS,IAAI,SAAS,CAAC,IAAI,KAAK,YAAY,CAAC,IAAI,EAAE,CAAC;YACtD,wEAAwE;YACxE,sEAAsE;YACtE,qEAAqE;YACrE,8DAA8D;YAC9D,yEAAyE;YACzE,MAAM,IAAI,KAAK,CACb,GAAG,sBAAU,mDAAmD,IAAI,CAAC,IAAI,QAAQ,SAAS,CAAC,IAAI,IAAI;gBACjG,8DAA8D,YAAY,CAAC,IAAI,IAAI;gBACnF,0EAA0E;gBAC1E,qFAAqF;gBACrF,kDAAkD,CACrD,CAAC;QACJ,CAAC;QACD,uEAAuE;QACvE,yDAAyD;QACzD,MAAM,OAAO,GAAG,GAAG,IAAI,CAAC,IAAI,MAAM,CAAC;QACnC,IAAA,uBAAa,EAAC,OAAO,EAAE,IAAA,4BAAY,EAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;QAChD,MAAM,aAAa,GAAkB;YACnC,IAAI,EAAE,iBAAI,CAAC,SAAS,CAAC,OAAO,CAAC;YAC7B,OAAO,EAAE,GAAG,2BAAgB,iBAAiB;YAC7C,UAAU,EAAE,IAAI;YAChB,OAAO,EAAE,IAAI,oBAAO,CAAC,YAAY,EAAE,0BAAa,CAAC,MAAM,CAAC;YACxD,OAAO,EAAE,sBAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;YAC7B,GAAG,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,IAAI,CAAC;YACtC,GAAG,cAAc,EAAE,aAAa;YAChC,wEAAwE;YACxE,0EAA0E;YAC1E,YAAY;YACZ,WAAW,EAAE;gBACX,qEAAqE;gBACrE,kEAAkE;gBAClE,qBAAqB;gBACrB,QAAQ,EAAE,YAAY;gBACtB,GAAG,IAAA,8CAAkB,EAAC,IAAI,CAAC,KAAK,CAAC;gBACjC,sEAAsE;gBACtE,mEAAmE;gBACnE,mEAAmE;gBACnE,sEAAsE;gBACtE,sBAAsB;gBACtB,CAAC,iCAAsB,CAAC,EAAE,IAAI,CAAC,IAAI;gBACnC,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,aAAa,EAAE,WAAW;gBACnD,GAAG,cAAc,EAAE,aAAa,EAAE,WAAW;aAC9C;SACF,CAAC;QAEF,MAAM,EAAE,GAAG,IAAI,qBAAc,CAAC,IAAI,EAAE,EAAE,EAAE,aAAa,CAAC,CAAC;QAEvD,IAAA,8CAAkB,EAAC,IAAI,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QAEnC,OAAO,EAAE,CAAC;IACZ,CAAC;IAED;;;;OAIG;IACK,mBAAmB,CACzB,SAAiB;QAEjB,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,aAAa,CAAC;QACnD,IAAI,CAAC,MAAM,IAAI,SAAS,KAAK,wCAAsB,EAAE,CAAC;YACpD,OAAO,MAAM,CAAC;QAChB,CAAC;QACD,MAAM,EAAE,YAAY,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,EAAE,GAAG,MAAM,CAAC;QACxD,OAAO,IAAI,CAAC;IACd,CAAC;;AAhJH,0CAiJC","sourcesContent":["import { writeFileSync } from \"node:fs\";\nimport { Duration } from \"aws-cdk-lib\";\nimport {\n  Architecture,\n  Code,\n  Function as LambdaFunction,\n  FunctionProps,\n  FunctionUrl,\n  FunctionUrlAuthType,\n  InvokeMode,\n  Runtime,\n  RuntimeFamily,\n} from \"aws-cdk-lib/aws-lambda\";\nimport { Construct } from \"constructs\";\nimport {\n  grantRuntimeAccess,\n  NextjsComputeBaseProps,\n  runtimeEnvironment,\n} from \"./nextjs-compute-base-props\";\nimport { DEFAULT_FUNCTION_GROUP } from \"../adapter/function-groups\";\nimport { LOG_PREFIX, NextjsType } from \"../constants\";\nimport { OptionalFunctionProps } from \"../generated-structs/OptionalFunctionProps\";\nimport { OptionalFunctionUrlProps } from \"../generated-structs/OptionalFunctionUrlProps\";\nimport { NextjsDeploymentRoot } from \"../nextjs-build/nextjs-build\";\nimport { FUNCTION_GROUP_ENV_VAR, RUNTIME_DIR_NAME } from \"../runtime/manifest\";\nimport { getLambdaArchitecture } from \"../utils/get-architecture\";\nimport { zipDirectory } from \"../utils/zip-directory\";\n\nexport interface NextjsFunctionsOverrides {\n  /**\n   * Props for the Lambda function.\n   *\n   * Construct-wide (`NextjsFunctionsProps.overrides`), these apply to every\n   * function group's Lambda — memory, timeout, VPC, role and the rest are\n   * shared — except the props that identify one function: `functionName`,\n   * `code` and `handler` apply to the `default` group only. A second function\n   * with the same name fails the deploy, and another group's code or handler\n   * would ship the wrong deployment root. Set those per group, in the group's\n   * own `overrides`, where they apply to that group alone.\n   */\n  readonly functionProps?: OptionalFunctionProps;\n  readonly functionUrlProps?: OptionalFunctionUrlProps;\n}\n\n/**\n * A set of routes to package into their own Lambda function.\n *\n * The only reason to reach for this is Lambda's 250 MB unzipped limit. Every\n * group ships the *same* Next.js runtime and the same shared code — splitting\n * only moves route-local code (and whatever it pulls in) out of the other\n * functions. So group by what is heavy, not by what is logically related.\n *\n * Each group becomes one Lambda function and one CloudFront behavior per\n * pattern, out of a per-distribution budget of 75 that `public/` entries also\n * draw on. Routes not matched by any group stay in the implicit `default` group.\n *\n * Patterns are an exact path or a subtree, and nothing else:\n *\n * - `/pricing` — that route, exactly.\n * - `/api/reports/**` — everything *under* `/api/reports`, including\n *   `/api/reports/[id]`, but not `/api/reports` itself. List both to own both.\n *\n * Dynamic segments (`/blog/[slug]`) and route groups (`/(marketing)/about`) are\n * synth errors: CloudFront path patterns support only `*` and `?`, so neither\n * could be honored at the granularity it implies. Use a subtree.\n *\n * When two patterns match a route, the longest wins — `/api/**` in one group and\n * `/api/reports/**` in another is a valid and useful pair.\n *\n * @example\n * functionGroups: [\n *   { name: \"reports\", routes: [\"/api/reports/**\"] },\n *   { name: \"admin\", routes: [\"/admin/**\"], overrides: { functionProps: { memorySize: 3008 } } },\n * ]\n */\nexport interface NextjsFunctionGroup {\n  /**\n   * Group name. Becomes a construct id and part of the Lambda function name, so\n   * it must match `/^[a-zA-Z0-9-]+$/`. `default` is reserved.\n   */\n  readonly name: string;\n  /** Path patterns this group owns. At least one; see {@link NextjsFunctionGroup}. */\n  readonly routes: string[];\n  /**\n   * Per-group overrides, merged over the construct-wide `overrides` — which is\n   * the point of splitting for anything other than size: a group can have its\n   * own memory, timeout, or concurrency. Not its own architecture: every group\n   * deploys the one the build staged `sharp` for.\n   */\n  readonly overrides?: NextjsFunctionsOverrides;\n}\n\n/** One deployed function group: its Lambda, its URL, and what it serves. */\nexport interface NextjsFunctionGroupResources {\n  /** Group name; `default` for the implicit catch-all group. */\n  readonly name: string;\n  /**\n   * Route templates packaged into this function, as the adapter assigned them.\n   * Empty for the default group is normal in a heavily split app.\n   */\n  readonly routes: string[];\n  readonly function: LambdaFunction;\n  /** Only for `GLOBAL_FUNCTIONS`; Regional fronts its functions with API Gateway. */\n  readonly functionUrl?: FunctionUrl;\n}\n\nexport interface NextjsFunctionsProps extends NextjsComputeBaseProps {\n  readonly overrides?: NextjsFunctionsOverrides;\n  /**\n   * The staged deployment roots, one per function group, `default` among them.\n   * @see NextjsBuild.deploymentRoots\n   */\n  readonly deploymentRoots: NextjsDeploymentRoot[];\n  /**\n   * The architecture `NextjsBuild` staged the deployment roots' native\n   * dependencies (`sharp`) for, which every function deploys.\n   * @see NextjsBuild.architecture\n   * @default - the architecture of the machine running synth, as `NextjsBuild`'s\n   */\n  readonly architecture?: Architecture;\n  /**\n   * Per-group configuration, keyed by name against {@link deploymentRoots}.\n   * Routes come from the build rather than from here, since the adapter resolved\n   * them; this only carries `overrides`.\n   */\n  readonly functionGroups?: NextjsFunctionGroup[];\n}\n\n/**\n * Run Next.js in functions on AWS with AWS Lambda.\n *\n * A plain zip function on the Node.js managed runtime: the deployment root\n * `NextjsBuild` staged is the asset, and cdk-nextjs's own bundled shell\n * (`cdk-nextjs-runtime/lambda.mjs`) is the handler. It invokes the entrypoints\n * `next build` produced in-process, so there is no Next.js HTTP server, no\n * Docker image, and no Lambda Web Adapter — response streaming comes from\n * `awslambda.streamifyResponse` directly.\n */\nexport class NextjsFunctions extends Construct {\n  /**\n   * The `default` group's function: the one the distribution's default behavior\n   * targets, and the only one at all unless `functionGroups` is used.\n   *\n   * A zip-packaged `lambda.Function` since 0.7.0; before that it was a\n   * `DockerImageFunction`. Code that relied on the image-specific type (its\n   * repository, or `DockerImageCode`) has to change.\n   */\n  function: LambdaFunction;\n  /** The `default` group's Function URL. Only for `GLOBAL_FUNCTIONS`. */\n  functionUrl?: FunctionUrl;\n  /**\n   * Every deployed group, `default` first. Iterate this rather than\n   * {@link function} for anything that must reach all of them — IAM grants and\n   * CloudFront behaviors both do.\n   */\n  functionGroups: NextjsFunctionGroupResources[];\n\n  private props: NextjsFunctionsProps;\n\n  constructor(scope: Construct, id: string, props: NextjsFunctionsProps) {\n    super(scope, id);\n    this.props = props;\n\n    const roots = props.deploymentRoots;\n    this.functionGroups = roots.map((root) => {\n      const group = props.functionGroups?.find((it) => it.name === root.name);\n      // The default group keeps the unsuffixed construct id it has always had,\n      // so adding `functionGroups` to a deployed app does not replace the\n      // function that was already serving everything.\n      const fn = this.createFunction(\n        root.name === DEFAULT_FUNCTION_GROUP\n          ? \"Functions\"\n          : `Functions-${root.name}`,\n        root,\n        group?.overrides,\n      );\n      let functionUrl: FunctionUrl | undefined;\n      if (props.nextjsType === NextjsType.GLOBAL_FUNCTIONS) {\n        functionUrl = fn.addFunctionUrl({\n          authType: FunctionUrlAuthType.AWS_IAM,\n          invokeMode: InvokeMode.RESPONSE_STREAM,\n          ...props.overrides?.functionUrlProps,\n          ...group?.overrides?.functionUrlProps,\n        });\n      }\n      return {\n        name: root.name,\n        routes: root.routes,\n        function: fn,\n        functionUrl,\n      };\n    });\n\n    const defaultGroup = this.functionGroups.find(\n      (group) => group.name === DEFAULT_FUNCTION_GROUP,\n    );\n    if (!defaultGroup) {\n      throw new Error(\n        `Expected a \"${DEFAULT_FUNCTION_GROUP}\" deployment root, got ` +\n          `[${roots.map((root) => root.name).join(\", \")}].`,\n      );\n    }\n    this.function = defaultGroup.function;\n    this.functionUrl = defaultGroup.functionUrl;\n  }\n\n  private createFunction(\n    id: string,\n    root: NextjsDeploymentRoot,\n    groupOverrides: NextjsFunctionsOverrides | undefined,\n  ) {\n    const architecture = this.props.architecture ?? getLambdaArchitecture();\n    const requested =\n      groupOverrides?.functionProps?.architecture ??\n      this.props.overrides?.functionProps?.architecture;\n    if (requested && requested.name !== architecture.name) {\n      // Ignoring it would deploy a function the user didn't ask for; honoring\n      // it would deploy one that can't load the `sharp` binaries staged for\n      // the root. The root constructs pass the same value to both unless a\n      // group's own override asks for another (one architecture per\n      // deployment), or `NextjsBuild` and `NextjsFunctions` are wired by hand.\n      throw new Error(\n        `${LOG_PREFIX} functionProps.architecture for function group \"${root.name}\" is ${requested.name}, ` +\n          `but NextjsBuild staged its native dependencies (sharp) for ${architecture.name}. ` +\n          \"Every function group deploys one architecture: set it construct-wide in \" +\n          \"`overrides.nextjsFunctions.functionProps` or, wiring the constructs yourself, pass \" +\n          \"NextjsBuild's `architecture` to NextjsFunctions.\",\n      );\n    }\n    // Zipped here rather than by `cdk-assets`, which would dereference the\n    // pnpm symlinks the root depends on; see `zipDirectory`.\n    const zipPath = `${root.path}.zip`;\n    writeFileSync(zipPath, zipDirectory(root.path));\n    const functionProps: FunctionProps = {\n      code: Code.fromAsset(zipPath),\n      handler: `${RUNTIME_DIR_NAME}/lambda.handler`,\n      memorySize: 2048,\n      runtime: new Runtime(\"nodejs24.x\", RuntimeFamily.NODEJS),\n      timeout: Duration.seconds(30),\n      ...this.sharedFunctionProps(root.name),\n      ...groupOverrides?.functionProps,\n      // After the overrides: the function must run what `NextjsBuild` staged.\n      // An override that disagrees throws above rather than being dropped here.\n      architecture,\n      environment: {\n        // What `next start` and the Containers Dockerfiles set. Externalized\n        // packages (React for Pages Router SSR among them) load their dev\n        // builds without it.\n        NODE_ENV: \"production\",\n        ...runtimeEnvironment(this.props),\n        // Which group this function is. Only used to make a misroute legible:\n        // if CloudFront sends a request here for a route that was packaged\n        // elsewhere, the 500 says which function got it and which group it\n        // belongs to, rather than surfacing as a module-not-found deep inside\n        // the Next.js server.\n        [FUNCTION_GROUP_ENV_VAR]: root.name,\n        ...this.props.overrides?.functionProps?.environment,\n        ...groupOverrides?.functionProps?.environment,\n      },\n    };\n\n    const fn = new LambdaFunction(this, id, functionProps);\n\n    grantRuntimeAccess(this.props, fn);\n\n    return fn;\n  }\n\n  /**\n   * The construct-wide `functionProps`, minus what identifies a single function\n   * when this is not the `default` group; see\n   * {@link NextjsFunctionsOverrides.functionProps}.\n   */\n  private sharedFunctionProps(\n    groupName: string,\n  ): OptionalFunctionProps | undefined {\n    const shared = this.props.overrides?.functionProps;\n    if (!shared || groupName === DEFAULT_FUNCTION_GROUP) {\n      return shared;\n    }\n    const { functionName, code, handler, ...rest } = shared;\n    return rest;\n  }\n}\n"]}

package/lib/nextjs-compute/nextjs-functions.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/nextjs-compute/nextjs-functions.test.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable import/no-extraneous-dependencies */
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const assertions_1 = require("aws-cdk-lib/assertions");
+const aws_dynamodb_1 = require("aws-cdk-lib/aws-dynamodb");
+const aws_lambda_1 = require("aws-cdk-lib/aws-lambda");
+const aws_s3_1 = require("aws-cdk-lib/aws-s3");
+const nextjs_functions_1 = require("./nextjs-functions");
+const constants_1 = require("../constants");
+describe("NextjsFunctions overrides", () => {
+    let dir;
+    beforeAll(() => {
+        dir = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "nextjs-functions-test-"));
+        for (const name of ["default", "reports", "other"]) {
+            // Distinct content, so each root is a distinct asset hash.
+            (0, node_fs_1.mkdirSync)((0, node_path_1.join)(dir, name));
+            (0, node_fs_1.writeFileSync)((0, node_path_1.join)(dir, name, "index.js"), `// ${name}`);
+        }
+    });
+    afterAll(() => {
+        (0, node_fs_1.rmSync)(dir, { recursive: true, force: true });
+    });
+    /** Lambda function properties by the group env var each function carries. */
+    function synth(overrides, groupOverrides, staged = aws_lambda_1.Architecture.X86_64) {
+        const stack = new aws_cdk_lib_1.Stack(new aws_cdk_lib_1.App(), "TestStack");
+        new nextjs_functions_1.NextjsFunctions(stack, "Functions", {
+            cacheBucket: new aws_s3_1.Bucket(stack, "Cache"),
+            revalidationTable: new aws_dynamodb_1.TableV2(stack, "Table", {
+                partitionKey: { name: "pk", type: aws_dynamodb_1.AttributeType.STRING },
+            }),
+            staticAssetsBucket: new aws_s3_1.Bucket(stack, "Assets"),
+            buildId: "build",
+            nextjsType: constants_1.NextjsType.REGIONAL_FUNCTIONS,
+            deploymentRoots: [
+                { name: "default", path: (0, node_path_1.join)(dir, "default"), routes: [] },
+                { name: "reports", path: (0, node_path_1.join)(dir, "reports"), routes: ["/reports"] },
+            ],
+            architecture: staged,
+            functionGroups: [
+                { name: "reports", routes: ["/reports"], overrides: groupOverrides },
+            ],
+            overrides,
+        });
+        const functions = assertions_1.Template.fromStack(stack).findResources("AWS::Lambda::Function");
+        return Object.fromEntries(Object.values(functions).map((fn) => [
+            fn.Properties.Environment.Variables.CDK_NEXTJS_FUNCTION_GROUP,
+            fn.Properties,
+        ]));
+    }
+    it("applies shared props to every group", () => {
+        const functions = synth({ functionProps: { memorySize: 3008 } });
+        expect(functions.default.MemorySize).toBe(3008);
+        expect(functions.reports.MemorySize).toBe(3008);
+    });
+    it("applies functionName, code and handler to the default group only", () => {
+        const functions = synth({
+            functionProps: {
+                functionName: "my-app",
+                code: aws_lambda_1.Code.fromAsset((0, node_path_1.join)(dir, "other")),
+                handler: "custom.handler",
+            },
+        });
+        expect(functions.default.FunctionName).toBe("my-app");
+        expect(functions.default.Handler).toBe("custom.handler");
+        expect(functions.reports.FunctionName).toBeUndefined();
+        expect(functions.reports.Handler).toBe("cdk-nextjs-runtime/lambda.handler");
+        // Each group still ships its own deployment root.
+        expect(functions.reports.Code).not.toEqual(functions.default.Code);
+    });
+    it("lets a group set its own functionName", () => {
+        const functions = synth({ functionProps: { functionName: "my-app" } }, { functionProps: { functionName: "my-app-reports" } });
+        expect(functions.default.FunctionName).toBe("my-app");
+        expect(functions.reports.FunctionName).toBe("my-app-reports");
+    });
+    describe("architecture", () => {
+        it("deploys what the roots were staged for, whatever this machine is", () => {
+            expect(synth({}).default.Architectures).toEqual(["x86_64"]);
+            const arm = synth({}, undefined, aws_lambda_1.Architecture.ARM_64);
+            expect(arm.default.Architectures).toEqual(["arm64"]);
+            expect(arm.reports.Architectures).toEqual(["arm64"]);
+        });
+        it("accepts an override that matches the staged binaries", () => {
+            const functions = synth({ functionProps: { architecture: aws_lambda_1.Architecture.ARM_64 } }, undefined, aws_lambda_1.Architecture.ARM_64);
+            expect(functions.default.Architectures).toEqual(["arm64"]);
+        });
+        // Silently deploying the staged architecture instead of the one asked for
+        // is how this used to fail. A group can't ask for its own either: one
+        // architecture per deployment.
+        it("throws on an override the staged binaries can't run on", () => {
+            expect(() => synth({ functionProps: { architecture: aws_lambda_1.Architecture.ARM_64 } })).toThrow(/staged its native dependencies \(sharp\) for x86_64/);
+            expect(() => synth({}, { functionProps: { architecture: aws_lambda_1.Architecture.ARM_64 } })).toThrow(/function group "reports" is arm64/);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nextjs-functions.test.js","sourceRoot":"","sources":["../../src/nextjs-compute/nextjs-functions.test.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable import/no-extraneous-dependencies */\nimport { mkdirSync, mkdtempSync, rmSync, writeFileSync } from \"node:fs\";\nimport { tmpdir } from \"node:os\";\nimport { join } from \"node:path\";\nimport { App, Stack } from \"aws-cdk-lib\";\nimport { Template } from \"aws-cdk-lib/assertions\";\nimport { AttributeType, TableV2 } from \"aws-cdk-lib/aws-dynamodb\";\nimport { Architecture, Code } from \"aws-cdk-lib/aws-lambda\";\nimport { Bucket } from \"aws-cdk-lib/aws-s3\";\nimport { NextjsFunctions, NextjsFunctionsOverrides } from \"./nextjs-functions\";\nimport { NextjsType } from \"../constants\";\n\ndescribe(\"NextjsFunctions overrides\", () => {\n  let dir: string;\n\n  beforeAll(() => {\n    dir = mkdtempSync(join(tmpdir(), \"nextjs-functions-test-\"));\n    for (const name of [\"default\", \"reports\", \"other\"]) {\n      // Distinct content, so each root is a distinct asset hash.\n      mkdirSync(join(dir, name));\n      writeFileSync(join(dir, name, \"index.js\"), `// ${name}`);\n    }\n  });\n\n  afterAll(() => {\n    rmSync(dir, { recursive: true, force: true });\n  });\n\n  /** Lambda function properties by the group env var each function carries. */\n  function synth(\n    overrides: NextjsFunctionsOverrides,\n    groupOverrides?: NextjsFunctionsOverrides,\n    staged: Architecture = Architecture.X86_64,\n  ) {\n    const stack = new Stack(new App(), \"TestStack\");\n    new NextjsFunctions(stack, \"Functions\", {\n      cacheBucket: new Bucket(stack, \"Cache\"),\n      revalidationTable: new TableV2(stack, \"Table\", {\n        partitionKey: { name: \"pk\", type: AttributeType.STRING },\n      }),\n      staticAssetsBucket: new Bucket(stack, \"Assets\"),\n      buildId: \"build\",\n      nextjsType: NextjsType.REGIONAL_FUNCTIONS,\n      deploymentRoots: [\n        { name: \"default\", path: join(dir, \"default\"), routes: [] },\n        { name: \"reports\", path: join(dir, \"reports\"), routes: [\"/reports\"] },\n      ],\n      architecture: staged,\n      functionGroups: [\n        { name: \"reports\", routes: [\"/reports\"], overrides: groupOverrides },\n      ],\n      overrides,\n    });\n    const functions = Template.fromStack(stack).findResources(\n      \"AWS::Lambda::Function\",\n    );\n    return Object.fromEntries(\n      Object.values(functions).map((fn) => [\n        fn.Properties.Environment.Variables.CDK_NEXTJS_FUNCTION_GROUP,\n        fn.Properties,\n      ]),\n    );\n  }\n\n  it(\"applies shared props to every group\", () => {\n    const functions = synth({ functionProps: { memorySize: 3008 } });\n\n    expect(functions.default.MemorySize).toBe(3008);\n    expect(functions.reports.MemorySize).toBe(3008);\n  });\n\n  it(\"applies functionName, code and handler to the default group only\", () => {\n    const functions = synth({\n      functionProps: {\n        functionName: \"my-app\",\n        code: Code.fromAsset(join(dir, \"other\")),\n        handler: \"custom.handler\",\n      },\n    });\n\n    expect(functions.default.FunctionName).toBe(\"my-app\");\n    expect(functions.default.Handler).toBe(\"custom.handler\");\n    expect(functions.reports.FunctionName).toBeUndefined();\n    expect(functions.reports.Handler).toBe(\"cdk-nextjs-runtime/lambda.handler\");\n    // Each group still ships its own deployment root.\n    expect(functions.reports.Code).not.toEqual(functions.default.Code);\n  });\n\n  it(\"lets a group set its own functionName\", () => {\n    const functions = synth(\n      { functionProps: { functionName: \"my-app\" } },\n      { functionProps: { functionName: \"my-app-reports\" } },\n    );\n\n    expect(functions.default.FunctionName).toBe(\"my-app\");\n    expect(functions.reports.FunctionName).toBe(\"my-app-reports\");\n  });\n\n  describe(\"architecture\", () => {\n    it(\"deploys what the roots were staged for, whatever this machine is\", () => {\n      expect(synth({}).default.Architectures).toEqual([\"x86_64\"]);\n      const arm = synth({}, undefined, Architecture.ARM_64);\n      expect(arm.default.Architectures).toEqual([\"arm64\"]);\n      expect(arm.reports.Architectures).toEqual([\"arm64\"]);\n    });\n\n    it(\"accepts an override that matches the staged binaries\", () => {\n      const functions = synth(\n        { functionProps: { architecture: Architecture.ARM_64 } },\n        undefined,\n        Architecture.ARM_64,\n      );\n      expect(functions.default.Architectures).toEqual([\"arm64\"]);\n    });\n\n    // Silently deploying the staged architecture instead of the one asked for\n    // is how this used to fail. A group can't ask for its own either: one\n    // architecture per deployment.\n    it(\"throws on an override the staged binaries can't run on\", () => {\n      expect(() =>\n        synth({ functionProps: { architecture: Architecture.ARM_64 } }),\n      ).toThrow(/staged its native dependencies \\(sharp\\) for x86_64/);\n      expect(() =>\n        synth({}, { functionProps: { architecture: Architecture.ARM_64 } }),\n      ).toThrow(/function group \"reports\" is arm64/);\n    });\n  });\n});\n"]}