[node-bridge] Support streaming response for Serverless Function (ver…

…cel#8795)

Adds streaming response support for React Server Components with Next 13.

packages/build-utils/src/lambda.ts

@@ -23,6 +23,7 @@ export interface LambdaOptionsBase {
   regions?: string[];
   supportsMultiPayloads?: boolean;
   supportsWrapper?: boolean;
+  experimentalResponseStreaming?: boolean;
 }
 
 export interface LambdaOptionsWithFiles extends LambdaOptionsBase {
@@ -60,6 +61,7 @@ export class Lambda {
   zipBuffer?: Buffer;
   supportsMultiPayloads?: boolean;
   supportsWrapper?: boolean;
+  experimentalResponseStreaming?: boolean;
 
   constructor(opts: LambdaOptions) {
     const {
@@ -72,6 +74,7 @@ export class Lambda {
       regions,
       supportsMultiPayloads,
       supportsWrapper,
+      experimentalResponseStreaming,
     } = opts;
     if ('files' in opts) {
       assert(typeof opts.files === 'object', '"files" must be an object');
@@ -132,6 +135,7 @@ export class Lambda {
     this.zipBuffer = 'zipBuffer' in opts ? opts.zipBuffer : undefined;
     this.supportsMultiPayloads = supportsMultiPayloads;
     this.supportsWrapper = supportsWrapper;
+    this.experimentalResponseStreaming = experimentalResponseStreaming;
   }
 
   async createZip(): Promise<Buffer> {

packages/next/src/server-build.ts

@@ -338,6 +338,7 @@ export async function serverBuild({
 
     const apiPages: string[] = [];
     const nonApiPages: string[] = [];
+    const streamingPages: string[] = [];
 
     lambdaPageKeys.forEach(page => {
       if (
@@ -359,6 +360,8 @@ export async function serverBuild({
 
       if (pageMatchesApi(page)) {
         apiPages.push(page);
+      } else if (appDir && lambdaAppPaths[page]) {
+        streamingPages.push(page);
       } else {
         nonApiPages.push(page);
       }
@@ -546,7 +549,12 @@ export async function serverBuild({
     const compressedPages: {
       [page: string]: PseudoFile;
     } = {};
-    const mergedPageKeys = [...nonApiPages, ...apiPages, ...internalPages];
+    const mergedPageKeys = [
+      ...nonApiPages,
+      ...streamingPages,
+      ...apiPages,
+      ...internalPages,
+    ];
     const traceCache = {};
 
     const getOriginalPagePath = (page: string) => {
@@ -704,6 +712,27 @@ export async function serverBuild({
       pageExtensions,
     });
 
+    const streamingPageLambdaGroups = await getPageLambdaGroups({
+      entryPath: requiredServerFilesManifest.appDir || entryPath,
+      config,
+      pages: streamingPages,
+      prerenderRoutes,
+      pageTraces,
+      compressedPages,
+      tracedPseudoLayer: tracedPseudoLayer.pseudoLayer,
+      initialPseudoLayer,
+      lambdaCompressedByteLimit,
+      initialPseudoLayerUncompressed: uncompressedInitialSize,
+      internalPages,
+      pageExtensions,
+    });
+
+    for (const group of streamingPageLambdaGroups) {
+      if (!group.isPrerenders) {
+        group.isStreaming = true;
+      }
+    }
+
     const apiLambdaGroups = await getPageLambdaGroups({
       entryPath: requiredServerFilesManifest.appDir || entryPath,
       config,
@@ -733,13 +762,23 @@ export async function serverBuild({
             pseudoLayerBytes: group.pseudoLayerBytes,
             uncompressedLayerBytes: group.pseudoLayerUncompressedBytes,
           })),
+          streamingPageLambdaGroups: streamingPageLambdaGroups.map(group => ({
+            pages: group.pages,
+            isPrerender: group.isPrerenders,
+            pseudoLayerBytes: group.pseudoLayerBytes,
+            uncompressedLayerBytes: group.pseudoLayerUncompressedBytes,
+          })),
           nextServerLayerSize: initialPseudoLayer.pseudoLayerBytes,
         },
         null,
         2
       )
     );
-    const combinedGroups = [...pageLambdaGroups, ...apiLambdaGroups];
+    const combinedGroups = [
+      ...pageLambdaGroups,
+      ...streamingPageLambdaGroups,
+      ...apiLambdaGroups,
+    ];
 
     await detectLambdaLimitExceeding(
       combinedGroups,
@@ -832,6 +871,7 @@ export async function serverBuild({
         memory: group.memory,
         runtime: nodeVersion.runtime,
         maxDuration: group.maxDuration,
+        isStreaming: group.isStreaming,
       });
 
       for (const page of group.pages) {

packages/next/src/utils.ts

@@ -748,6 +748,7 @@ export async function createPseudoLayer(files: {
 
 interface CreateLambdaFromPseudoLayersOptions extends LambdaOptionsWithFiles {
   layers: PseudoLayer[];
+  isStreaming?: boolean;
 }
 
 // measured with 1, 2, 5, 10, and `os.cpus().length || 5`
@@ -757,6 +758,7 @@ const createLambdaSema = new Sema(1);
 export async function createLambdaFromPseudoLayers({
   files: baseFiles,
   layers,
+  isStreaming,
   ...lambdaOptions
 }: CreateLambdaFromPseudoLayersOptions) {
   await createLambdaSema.acquire();
@@ -791,6 +793,11 @@ export async function createLambdaFromPseudoLayers({
 
   return new NodejsLambda({
     ...lambdaOptions,
+    ...(isStreaming
+      ? {
+          experimentalResponseStreaming: true,
+        }
+      : {}),
     files,
     shouldAddHelpers: false,
     shouldAddSourcemapSupport: false,
@@ -1273,6 +1280,7 @@ export type LambdaGroup = {
   pages: string[];
   memory?: number;
   maxDuration?: number;
+  isStreaming?: boolean;
   isPrerenders?: boolean;
   pseudoLayer: PseudoLayer;
   pseudoLayerBytes: number;

packages/next/test/integration/index.test.js

@@ -7,77 +7,80 @@ const runBuildLambda = require('../../../../test/lib/run-build-lambda');
 
 jest.setTimeout(360000);
 
-it('should build with app-dir correctly', async () => {
-  const { buildResult } = await runBuildLambda(
-    path.join(__dirname, '../fixtures/00-app-dir')
-  );
+// experimental appDir currently requires Node.js >= 16
+if (parseInt(process.versions.node.split('.')[0], 10) >= 16) {
+  it('should build with app-dir correctly', async () => {
+    const { buildResult } = await runBuildLambda(
+      path.join(__dirname, '../fixtures/00-app-dir')
+    );
 
-  const lambdas = new Set();
+    const lambdas = new Set();
 
-  for (const key of Object.keys(buildResult.output)) {
-    if (buildResult.output[key].type === 'Lambda') {
-      lambdas.add(buildResult.output[key]);
+    for (const key of Object.keys(buildResult.output)) {
+      if (buildResult.output[key].type === 'Lambda') {
+        lambdas.add(buildResult.output[key]);
+      }
     }
-  }
 
-  expect(lambdas.size).toBe(2);
-  expect(buildResult.output['dashboard']).toBeDefined();
-  expect(buildResult.output['dashboard/another']).toBeDefined();
-  expect(buildResult.output['dashboard/changelog']).toBeDefined();
-  expect(buildResult.output['dashboard/deployments/[id]']).toBeDefined();
+    expect(lambdas.size).toBe(2);
+    expect(buildResult.output['dashboard']).toBeDefined();
+    expect(buildResult.output['dashboard/another']).toBeDefined();
+    expect(buildResult.output['dashboard/changelog']).toBeDefined();
+    expect(buildResult.output['dashboard/deployments/[id]']).toBeDefined();
 
-  // prefixed static generation output with `/app` under dist server files
-  expect(buildResult.output['dashboard'].type).toBe('Prerender');
-  expect(buildResult.output['dashboard'].fallback.fsPath).toMatch(
-    /server\/app\/dashboard\.html$/
-  );
-  expect(buildResult.output['dashboard.rsc'].type).toBe('Prerender');
-  expect(buildResult.output['dashboard.rsc'].fallback.fsPath).toMatch(
-    /server\/app\/dashboard\.rsc$/
-  );
-  expect(buildResult.output['dashboard/index/index'].type).toBe('Prerender');
-  expect(buildResult.output['dashboard/index/index'].fallback.fsPath).toMatch(
-    /server\/app\/dashboard\/index\.html$/
-  );
-  expect(buildResult.output['dashboard/index.rsc'].type).toBe('Prerender');
-  expect(buildResult.output['dashboard/index.rsc'].fallback.fsPath).toMatch(
-    /server\/app\/dashboard\/index\.rsc$/
-  );
-});
+    // prefixed static generation output with `/app` under dist server files
+    expect(buildResult.output['dashboard'].type).toBe('Prerender');
+    expect(buildResult.output['dashboard'].fallback.fsPath).toMatch(
+      /server\/app\/dashboard\.html$/
+    );
+    expect(buildResult.output['dashboard.rsc'].type).toBe('Prerender');
+    expect(buildResult.output['dashboard.rsc'].fallback.fsPath).toMatch(
+      /server\/app\/dashboard\.rsc$/
+    );
+    expect(buildResult.output['dashboard/index/index'].type).toBe('Prerender');
+    expect(buildResult.output['dashboard/index/index'].fallback.fsPath).toMatch(
+      /server\/app\/dashboard\/index\.html$/
+    );
+    expect(buildResult.output['dashboard/index.rsc'].type).toBe('Prerender');
+    expect(buildResult.output['dashboard/index.rsc'].fallback.fsPath).toMatch(
+      /server\/app\/dashboard\/index\.rsc$/
+    );
+  });
 
-it('should build with app-dir in edge runtime correctly', async () => {
-  const { buildResult } = await runBuildLambda(
-    path.join(__dirname, '../fixtures/00-app-dir-edge')
-  );
+  it('should build with app-dir in edge runtime correctly', async () => {
+    const { buildResult } = await runBuildLambda(
+      path.join(__dirname, '../fixtures/00-app-dir-edge')
+    );
 
-  const edgeFunctions = new Set();
+    const edgeFunctions = new Set();
 
-  for (const key of Object.keys(buildResult.output)) {
-    if (buildResult.output[key].type === 'EdgeFunction') {
-      edgeFunctions.add(buildResult.output[key]);
+    for (const key of Object.keys(buildResult.output)) {
+      if (buildResult.output[key].type === 'EdgeFunction') {
+        edgeFunctions.add(buildResult.output[key]);
+      }
     }
-  }
 
-  expect(edgeFunctions.size).toBe(3);
-  expect(buildResult.output['edge']).toBeDefined();
-  expect(buildResult.output['index']).toBeDefined();
-  expect(buildResult.output['index/index']).toBeDefined();
-});
+    expect(edgeFunctions.size).toBe(3);
+    expect(buildResult.output['edge']).toBeDefined();
+    expect(buildResult.output['index']).toBeDefined();
+    expect(buildResult.output['index/index']).toBeDefined();
+  });
 
-it('should show error from basePath with legacy monorepo build', async () => {
-  let error;
+  it('should show error from basePath with legacy monorepo build', async () => {
+    let error;
 
-  try {
-    await runBuildLambda(path.join(__dirname, 'legacy-monorepo-basepath'));
-  } catch (err) {
-    error = err;
-  }
-  console.error(error);
+    try {
+      await runBuildLambda(path.join(__dirname, 'legacy-monorepo-basepath'));
+    } catch (err) {
+      error = err;
+    }
+    console.error(error);
 
-  expect(error.message).toBe(
-    'basePath can not be used with `builds` in vercel.json, use Project Settings to configure your monorepo instead'
-  );
-});
+    expect(error.message).toBe(
+      'basePath can not be used with `builds` in vercel.json, use Project Settings to configure your monorepo instead'
+    );
+  });
+}
 
 it('should build using server build', async () => {
   const origLog = console.log;