mirror of
https://github.com/facebook/react.git
synced 2025-11-01 09:12:30 +00:00
Sebastian Markbåge
143d3e1b89
The semantics of React is that anything outside of Suspense boundaries in a transition doesn't display until it has fully unsuspended. With SSR streaming the intention is to preserve that. We explicitly don't want to support the mode of document streaming normally supported by the browser where it can paint content as tags stream in since that leads to content popping in and thrashing in unpredictable ways. This should instead be modeled explictly by nested Suspense boundaries or something like SuspenseList. After the first shell any nested Suspense boundaries are only revealed, by script, once they're fully streamed in to the next boundary. So this is already the case there. However, for the initial shell we have been at the mercy of browser heuristics for how long it decides to stream before the first paint. Chromium now has [an API explicitly for this use case](https://developer.mozilla.org/en-US/docs/Web/API/View_Transition_API/Using#stabilizing_page_state_to_make_cross-document_transitions_consistent) that lets us model the semantics that we want. This is always important but especially so with MPA View Transitions. After this a simple document looks like this: ```html <!DOCTYPE html> <html> <head> <link rel="expect" href="#«R»" blocking="render"/> </head> <body> <p>hello world</p> <script src="bootstrap.js" id="«R»" async=""></script> ... </body> </html> ``` The `rel="expect"` tag indicates that we want to wait to paint until we have streamed far enough to be able to paint the id `"«R»"` which indicates the shell. Ideally this `id` would be assigned to the root most HTML element in the body. However, this is tricky in our implementation because there can be multiple and we can render them out of order. So instead, we assign the id to the first bootstrap script if there is one since these are always added to the end of the shell. If there isn't a bootstrap script then we emit an empty `<template id="«R»"></template>` instead as a marker. Since we currently put as much as possible in the shell if it's loaded by the time we render, this can have some negative effects for very large documents. We should instead apply the heuristic where very large Suspense boundaries get outlined outside the shell even if they're immediately available. This means that even prerenders can end up with script tags. We only emit the `rel="expect"` if you're rendering a whole document. I.e. if you rendered either a `<html>` or `<head>` tag. If you're rendering a partial document, then we don't really know where the streaming parts are anyway and can't provide such guarantees. This does apply whether you're streaming or not because we still want to block rendering until the end, but in practice any serialized state that needs hydrate should still be embedded after the completion id.
595 lines
19 KiB
JavaScript
595 lines
19 KiB
JavaScript
/**
|
|
* Copyright (c) Meta Platforms, Inc. and affiliates.
|
|
*
|
|
* This source code is licensed under the MIT license found in the
|
|
* LICENSE file in the root directory of this source tree.
|
|
*
|
|
* @emails react-core
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
import {patchMessageChannel} from '../../../../scripts/jest/patchMessageChannel';
|
|
|
|
// Polyfills for test environment
|
|
global.ReadableStream =
|
|
require('web-streams-polyfill/ponyfill/es6').ReadableStream;
|
|
global.TextEncoder = require('util').TextEncoder;
|
|
|
|
let React;
|
|
let ReactDOMFizzServer;
|
|
let Suspense;
|
|
let Scheduler;
|
|
let act;
|
|
|
|
describe('ReactDOMFizzServerBrowser', () => {
|
|
beforeEach(() => {
|
|
jest.resetModules();
|
|
|
|
Scheduler = require('scheduler');
|
|
patchMessageChannel(Scheduler);
|
|
act = require('internal-test-utils').act;
|
|
|
|
React = require('react');
|
|
ReactDOMFizzServer = require('react-dom/server.browser');
|
|
Suspense = React.Suspense;
|
|
});
|
|
|
|
async function serverAct(callback) {
|
|
let maybePromise;
|
|
await act(() => {
|
|
maybePromise = callback();
|
|
if (maybePromise && typeof maybePromise.catch === 'function') {
|
|
maybePromise.catch(() => {});
|
|
}
|
|
});
|
|
return maybePromise;
|
|
}
|
|
|
|
const theError = new Error('This is an error');
|
|
function Throw() {
|
|
throw theError;
|
|
}
|
|
const theInfinitePromise = new Promise(() => {});
|
|
function InfiniteSuspend() {
|
|
throw theInfinitePromise;
|
|
}
|
|
|
|
async function readResult(stream) {
|
|
const reader = stream.getReader();
|
|
let result = '';
|
|
while (true) {
|
|
const {done, value} = await reader.read();
|
|
if (done) {
|
|
return result;
|
|
}
|
|
result += Buffer.from(value).toString('utf8');
|
|
}
|
|
}
|
|
|
|
it('should call renderToReadableStream', async () => {
|
|
const stream = await serverAct(() =>
|
|
ReactDOMFizzServer.renderToReadableStream(<div>hello world</div>),
|
|
);
|
|
const result = await readResult(stream);
|
|
expect(result).toMatchInlineSnapshot(`"<div>hello world</div>"`);
|
|
});
|
|
|
|
it('should emit DOCTYPE at the root of the document', async () => {
|
|
const stream = await serverAct(() =>
|
|
ReactDOMFizzServer.renderToReadableStream(
|
|
<html>
|
|
<body>hello world</body>
|
|
</html>,
|
|
),
|
|
);
|
|
const result = await readResult(stream);
|
|
expect(result).toMatchInlineSnapshot(
|
|
`"<!DOCTYPE html><html><head><link rel="expect" href="#«R»" blocking="render"/></head><body>hello world<template id="«R»"></template></body></html>"`,
|
|
);
|
|
});
|
|
|
|
it('should emit bootstrap script src at the end', async () => {
|
|
const stream = await serverAct(() =>
|
|
ReactDOMFizzServer.renderToReadableStream(<div>hello world</div>, {
|
|
bootstrapScriptContent: 'INIT();',
|
|
bootstrapScripts: ['init.js'],
|
|
bootstrapModules: ['init.mjs'],
|
|
}),
|
|
);
|
|
const result = await readResult(stream);
|
|
expect(result).toMatchInlineSnapshot(
|
|
`"<link rel="preload" as="script" fetchPriority="low" href="init.js"/><link rel="modulepreload" fetchPriority="low" href="init.mjs"/><div>hello world</div><script id="«R»">INIT();</script><script src="init.js" async=""></script><script type="module" src="init.mjs" async=""></script>"`,
|
|
);
|
|
});
|
|
|
|
it('emits all HTML as one unit if we wait until the end to start', async () => {
|
|
let hasLoaded = false;
|
|
let resolve;
|
|
const promise = new Promise(r => (resolve = r));
|
|
function Wait() {
|
|
if (!hasLoaded) {
|
|
throw promise;
|
|
}
|
|
return 'Done';
|
|
}
|
|
let isComplete = false;
|
|
const stream = await serverAct(() =>
|
|
ReactDOMFizzServer.renderToReadableStream(
|
|
<div>
|
|
<Suspense fallback="Loading">
|
|
<Wait />
|
|
</Suspense>
|
|
</div>,
|
|
),
|
|
);
|
|
|
|
stream.allReady.then(() => (isComplete = true));
|
|
|
|
expect(isComplete).toBe(false);
|
|
// Resolve the loading.
|
|
hasLoaded = true;
|
|
await serverAct(() => resolve());
|
|
|
|
expect(isComplete).toBe(true);
|
|
|
|
const result = await readResult(stream);
|
|
expect(result).toMatchInlineSnapshot(
|
|
`"<div><!--$-->Done<!-- --><!--/$--></div>"`,
|
|
);
|
|
});
|
|
|
|
it('should reject the promise when an error is thrown at the root', async () => {
|
|
const reportedErrors = [];
|
|
let caughtError = null;
|
|
try {
|
|
await serverAct(() =>
|
|
ReactDOMFizzServer.renderToReadableStream(
|
|
<div>
|
|
<Throw />
|
|
</div>,
|
|
{
|
|
onError(x) {
|
|
reportedErrors.push(x);
|
|
},
|
|
},
|
|
),
|
|
);
|
|
} catch (error) {
|
|
caughtError = error;
|
|
}
|
|
expect(caughtError).toBe(theError);
|
|
expect(reportedErrors).toEqual([theError]);
|
|
});
|
|
|
|
it('should reject the promise when an error is thrown inside a fallback', async () => {
|
|
const reportedErrors = [];
|
|
let caughtError = null;
|
|
try {
|
|
await serverAct(() =>
|
|
ReactDOMFizzServer.renderToReadableStream(
|
|
<div>
|
|
<Suspense fallback={<Throw />}>
|
|
<InfiniteSuspend />
|
|
</Suspense>
|
|
</div>,
|
|
{
|
|
onError(x) {
|
|
reportedErrors.push(x);
|
|
},
|
|
},
|
|
),
|
|
);
|
|
} catch (error) {
|
|
caughtError = error;
|
|
}
|
|
expect(caughtError).toBe(theError);
|
|
expect(reportedErrors).toEqual([theError]);
|
|
});
|
|
|
|
it('should not error the stream when an error is thrown inside suspense boundary', async () => {
|
|
const reportedErrors = [];
|
|
const stream = await serverAct(() =>
|
|
ReactDOMFizzServer.renderToReadableStream(
|
|
<div>
|
|
<Suspense fallback={<div>Loading</div>}>
|
|
<Throw />
|
|
</Suspense>
|
|
</div>,
|
|
{
|
|
onError(x) {
|
|
reportedErrors.push(x);
|
|
},
|
|
},
|
|
),
|
|
);
|
|
|
|
const result = await readResult(stream);
|
|
expect(result).toContain('Loading');
|
|
expect(reportedErrors).toEqual([theError]);
|
|
});
|
|
|
|
it('should be able to complete by aborting even if the promise never resolves', async () => {
|
|
const errors = [];
|
|
const controller = new AbortController();
|
|
const stream = await serverAct(() =>
|
|
ReactDOMFizzServer.renderToReadableStream(
|
|
<div>
|
|
<Suspense fallback={<div>Loading</div>}>
|
|
<InfiniteSuspend />
|
|
</Suspense>
|
|
</div>,
|
|
{
|
|
signal: controller.signal,
|
|
onError(x) {
|
|
errors.push(x.message);
|
|
},
|
|
},
|
|
),
|
|
);
|
|
|
|
controller.abort();
|
|
|
|
const result = await readResult(stream);
|
|
expect(result).toContain('Loading');
|
|
|
|
expect(errors).toEqual(['The operation was aborted.']);
|
|
});
|
|
|
|
it('should reject if aborting before the shell is complete', async () => {
|
|
const errors = [];
|
|
const controller = new AbortController();
|
|
const promise = serverAct(() =>
|
|
ReactDOMFizzServer.renderToReadableStream(
|
|
<div>
|
|
<InfiniteSuspend />
|
|
</div>,
|
|
{
|
|
signal: controller.signal,
|
|
onError(x) {
|
|
errors.push(x.message);
|
|
},
|
|
},
|
|
),
|
|
);
|
|
|
|
const theReason = new Error('aborted for reasons');
|
|
controller.abort(theReason);
|
|
|
|
let caughtError = null;
|
|
try {
|
|
await promise;
|
|
} catch (error) {
|
|
caughtError = error;
|
|
}
|
|
expect(caughtError).toBe(theReason);
|
|
expect(errors).toEqual(['aborted for reasons']);
|
|
});
|
|
|
|
it('should be able to abort before something suspends', async () => {
|
|
const errors = [];
|
|
const controller = new AbortController();
|
|
function App() {
|
|
controller.abort();
|
|
return (
|
|
<Suspense fallback={<div>Loading</div>}>
|
|
<InfiniteSuspend />
|
|
</Suspense>
|
|
);
|
|
}
|
|
const streamPromise = serverAct(() =>
|
|
ReactDOMFizzServer.renderToReadableStream(
|
|
<div>
|
|
<App />
|
|
</div>,
|
|
{
|
|
signal: controller.signal,
|
|
onError(x) {
|
|
errors.push(x.message);
|
|
},
|
|
},
|
|
),
|
|
);
|
|
|
|
let caughtError = null;
|
|
try {
|
|
await streamPromise;
|
|
} catch (error) {
|
|
caughtError = error;
|
|
}
|
|
expect(caughtError.message).toBe('The operation was aborted.');
|
|
expect(errors).toEqual(['The operation was aborted.']);
|
|
});
|
|
|
|
it('should reject if passing an already aborted signal', async () => {
|
|
const errors = [];
|
|
const controller = new AbortController();
|
|
const theReason = new Error('aborted for reasons');
|
|
controller.abort(theReason);
|
|
|
|
const promise = serverAct(() =>
|
|
ReactDOMFizzServer.renderToReadableStream(
|
|
<div>
|
|
<Suspense fallback={<div>Loading</div>}>
|
|
<InfiniteSuspend />
|
|
</Suspense>
|
|
</div>,
|
|
{
|
|
signal: controller.signal,
|
|
onError(x) {
|
|
errors.push(x.message);
|
|
},
|
|
},
|
|
),
|
|
);
|
|
|
|
// Technically we could still continue rendering the shell but currently the
|
|
// semantics mean that we also abort any pending CPU work.
|
|
let caughtError = null;
|
|
try {
|
|
await promise;
|
|
} catch (error) {
|
|
caughtError = error;
|
|
}
|
|
expect(caughtError).toBe(theReason);
|
|
expect(errors).toEqual(['aborted for reasons']);
|
|
});
|
|
|
|
it('should not continue rendering after the reader cancels', async () => {
|
|
let hasLoaded = false;
|
|
let resolve;
|
|
let isComplete = false;
|
|
let rendered = false;
|
|
const promise = new Promise(r => (resolve = r));
|
|
function Wait() {
|
|
if (!hasLoaded) {
|
|
throw promise;
|
|
}
|
|
rendered = true;
|
|
return 'Done';
|
|
}
|
|
const errors = [];
|
|
const stream = await serverAct(() =>
|
|
ReactDOMFizzServer.renderToReadableStream(
|
|
<div>
|
|
<Suspense fallback={<div>Loading</div>}>
|
|
<Wait />
|
|
</Suspense>
|
|
</div>,
|
|
{
|
|
onError(x) {
|
|
errors.push(x.message);
|
|
},
|
|
},
|
|
),
|
|
);
|
|
|
|
stream.allReady.then(() => (isComplete = true));
|
|
|
|
expect(rendered).toBe(false);
|
|
expect(isComplete).toBe(false);
|
|
|
|
const reader = stream.getReader();
|
|
await reader.read();
|
|
await reader.cancel();
|
|
|
|
expect(errors).toEqual([
|
|
'The render was aborted by the server without a reason.',
|
|
]);
|
|
|
|
hasLoaded = true;
|
|
await serverAct(() => resolve());
|
|
|
|
expect(rendered).toBe(false);
|
|
expect(isComplete).toBe(true);
|
|
|
|
expect(errors).toEqual([
|
|
'The render was aborted by the server without a reason.',
|
|
]);
|
|
});
|
|
|
|
it('should stream large contents that might overlow individual buffers', async () => {
|
|
const str492 = `(492) This string is intentionally 492 bytes long because we want to make sure we process chunks that will overflow buffer boundaries. It will repeat to fill out the bytes required (inclusive of this prompt):: foo bar qux quux corge grault garply waldo fred plugh xyzzy thud foo bar qux quux corge grault garply waldo fred plugh xyzzy thud foo bar qux quux corge grault garply waldo fred plugh xyzzy thud foo bar qux quux corge grault garply waldo fred plugh xyzzy thud foo bar qux q :: total count (492)`;
|
|
const str2049 = `(2049) This string is intentionally 2049 bytes long because we want to make sure we process chunks that will overflow buffer boundaries. It will repeat to fill out the bytes required (inclusive of this prompt):: foo bar qux quux corge grault garply waldo fred plugh xyzzy thud foo bar qux quux corge grault garply waldo fred plugh xyzzy thud foo bar qux quux corge grault garply waldo fred plugh xyzzy thud foo bar qux quux corge grault garply waldo fred plugh xyzzy thud foo bar qux quux corge grault garply waldo fred plugh xyzzy thud foo bar qux quux corge grault garply waldo fred plugh xyzzy thud foo bar qux quux corge grault garply waldo fred plugh xyzzy thud foo bar qux quux corge grault garply waldo fred plugh xyzzy thud foo bar qux quux corge grault garply waldo fred plugh xyzzy thud foo bar qux quux corge grault garply waldo fred plugh xyzzy thud foo bar qux quux corge grault garply waldo fred plugh xyzzy thud foo bar qux quux corge grault garply waldo fred plugh xyzzy thud foo bar qux quux corge grault garply waldo fred plugh xyzzy thud foo bar qux quux corge grault garply waldo fred plugh xyzzy thud foo bar qux quux corge grault garply waldo fred plugh xyzzy thud foo bar qux quux corge grault garply waldo fred plugh xyzzy thud foo bar qux quux corge grault garply waldo fred plugh xyzzy thud foo bar qux quux corge grault garply waldo fred plugh xyzzy thud foo bar qux quux corge grault garply waldo fred plugh xyzzy thud foo bar qux quux corge grault garply waldo fred plugh xyzzy thud foo bar qux quux corge grault garply waldo fred plugh xyzzy thud foo bar qux quux corge grault garply waldo fred plugh xyzzy thud foo bar qux quux corge grault garply waldo fred plugh xyzzy thud foo bar qux quux corge grault garply waldo fred plugh xyzzy thud foo bar qux quux corge grault garply waldo fred plugh xyzzy thud foo bar qux quux corge grault garply waldo fred plugh xyzzy thud foo bar qux quux corge grault garply waldo fred plugh xyzzy thud foo bar qux quux corge grault garply waldo fred plugh xyzzy :: total count (2049)`;
|
|
|
|
// this specific layout is somewhat contrived to exercise the landing on
|
|
// an exact view boundary. it's not critical to test this edge case but
|
|
// since we are setting up a test in general for larger chunks I contrived it
|
|
// as such for now. I don't think it needs to be maintained if in the future
|
|
// the view sizes change or become dynamic becasue of the use of byobRequest
|
|
let stream;
|
|
stream = await serverAct(() =>
|
|
ReactDOMFizzServer.renderToReadableStream(
|
|
<>
|
|
<div>
|
|
<span>{''}</span>
|
|
</div>
|
|
<div>{str492}</div>
|
|
<div>{str492}</div>
|
|
</>,
|
|
),
|
|
);
|
|
|
|
let result;
|
|
result = await readResult(stream);
|
|
|
|
expect(result).toMatchInlineSnapshot(
|
|
// TODO: remove interpolation because it prevents snapshot updates.
|
|
// eslint-disable-next-line jest/no-interpolation-in-snapshots
|
|
`"<div><span></span></div><div>${str492}</div><div>${str492}</div>"`,
|
|
);
|
|
|
|
// this size 2049 was chosen to be a couple base 2 orders larger than the current view
|
|
// size. if the size changes in the future hopefully this will still exercise
|
|
// a chunk that is too large for the view size.
|
|
stream = await serverAct(() =>
|
|
ReactDOMFizzServer.renderToReadableStream(
|
|
<>
|
|
<div>{str2049}</div>
|
|
</>,
|
|
),
|
|
);
|
|
|
|
result = await readResult(stream);
|
|
// TODO: remove interpolation because it prevents snapshot updates.
|
|
// eslint-disable-next-line jest/no-interpolation-in-snapshots
|
|
expect(result).toMatchInlineSnapshot(`"<div>${str2049}</div>"`);
|
|
});
|
|
|
|
it('supports custom abort reasons with a string', async () => {
|
|
const promise = new Promise(r => {});
|
|
function Wait() {
|
|
throw promise;
|
|
}
|
|
function App() {
|
|
return (
|
|
<div>
|
|
<p>
|
|
<Suspense fallback={'p'}>
|
|
<Wait />
|
|
</Suspense>
|
|
</p>
|
|
<span>
|
|
<Suspense fallback={'span'}>
|
|
<Wait />
|
|
</Suspense>
|
|
</span>
|
|
</div>
|
|
);
|
|
}
|
|
|
|
const errors = [];
|
|
const controller = new AbortController();
|
|
await serverAct(() =>
|
|
ReactDOMFizzServer.renderToReadableStream(<App />, {
|
|
signal: controller.signal,
|
|
onError(x) {
|
|
errors.push(x);
|
|
return 'a digest';
|
|
},
|
|
}),
|
|
);
|
|
|
|
controller.abort('foobar');
|
|
|
|
expect(errors).toEqual(['foobar', 'foobar']);
|
|
});
|
|
|
|
it('supports custom abort reasons with an Error', async () => {
|
|
const promise = new Promise(r => {});
|
|
function Wait() {
|
|
throw promise;
|
|
}
|
|
function App() {
|
|
return (
|
|
<div>
|
|
<p>
|
|
<Suspense fallback={'p'}>
|
|
<Wait />
|
|
</Suspense>
|
|
</p>
|
|
<span>
|
|
<Suspense fallback={'span'}>
|
|
<Wait />
|
|
</Suspense>
|
|
</span>
|
|
</div>
|
|
);
|
|
}
|
|
|
|
const errors = [];
|
|
const controller = new AbortController();
|
|
await serverAct(() =>
|
|
ReactDOMFizzServer.renderToReadableStream(<App />, {
|
|
signal: controller.signal,
|
|
onError(x) {
|
|
errors.push(x.message);
|
|
return 'a digest';
|
|
},
|
|
}),
|
|
);
|
|
|
|
controller.abort(new Error('uh oh'));
|
|
|
|
expect(errors).toEqual(['uh oh', 'uh oh']);
|
|
});
|
|
|
|
// https://github.com/facebook/react/pull/25534/files - fix transposed escape functions
|
|
it('should encode title properly', async () => {
|
|
const stream = await serverAct(() =>
|
|
ReactDOMFizzServer.renderToReadableStream(
|
|
<html>
|
|
<head>
|
|
<title>foo</title>
|
|
</head>
|
|
<body>bar</body>
|
|
</html>,
|
|
),
|
|
);
|
|
|
|
const result = await readResult(stream);
|
|
expect(result).toEqual(
|
|
'<!DOCTYPE html><html><head><link rel="expect" href="#«R»" blocking="render"/><title>foo</title></head><body>bar<template id="«R»"></template></body></html>',
|
|
);
|
|
});
|
|
|
|
it('should support nonce attribute for bootstrap scripts', async () => {
|
|
const nonce = 'R4nd0m';
|
|
const stream = await serverAct(() =>
|
|
ReactDOMFizzServer.renderToReadableStream(<div>hello world</div>, {
|
|
nonce,
|
|
bootstrapScriptContent: 'INIT();',
|
|
bootstrapScripts: ['init.js'],
|
|
bootstrapModules: ['init.mjs'],
|
|
}),
|
|
);
|
|
const result = await readResult(stream);
|
|
expect(result).toMatchInlineSnapshot(
|
|
// TODO: remove interpolation because it prevents snapshot updates.
|
|
// eslint-disable-next-line jest/no-interpolation-in-snapshots
|
|
`"<link rel="preload" as="script" fetchPriority="low" nonce="R4nd0m" href="init.js"/><link rel="modulepreload" fetchPriority="low" nonce="R4nd0m" href="init.mjs"/><div>hello world</div><script nonce="${nonce}" id="«R»">INIT();</script><script src="init.js" nonce="${nonce}" async=""></script><script type="module" src="init.mjs" nonce="${nonce}" async=""></script>"`,
|
|
);
|
|
});
|
|
|
|
// @gate enablePostpone
|
|
it('errors if trying to postpone outside a Suspense boundary', async () => {
|
|
function Postponed() {
|
|
React.unstable_postpone('testing postpone');
|
|
return 'client only';
|
|
}
|
|
|
|
function App() {
|
|
return (
|
|
<div>
|
|
<Postponed />
|
|
</div>
|
|
);
|
|
}
|
|
|
|
const errors = [];
|
|
const postponed = [];
|
|
|
|
let caughtError = null;
|
|
try {
|
|
await serverAct(() =>
|
|
ReactDOMFizzServer.renderToReadableStream(<App />, {
|
|
onError(error) {
|
|
errors.push(error.message);
|
|
},
|
|
onPostpone(reason) {
|
|
postponed.push(reason);
|
|
},
|
|
}),
|
|
);
|
|
} catch (error) {
|
|
caughtError = error;
|
|
}
|
|
|
|
// Postponing is not logged as an error but as a postponed reason.
|
|
expect(errors).toEqual([]);
|
|
expect(postponed).toEqual(['testing postpone']);
|
|
// However, it does error the shell.
|
|
expect(caughtError.message).toEqual('testing postpone');
|
|
});
|
|
});
|