Unverified Commit 2220d732 authored by Jiachi Liu's avatar Jiachi Liu Committed by GitHub

[metadata] new metadata insertion API and support PPR (#75366)

parent d27cdc04
......@@ -797,9 +797,6 @@ function finishPendingCacheNode(
// a pending promise that needs to be resolved with the dynamic head from
// the server.
const head = cacheNode.head
// TODO: change head back to ReactNode when metadata
// is stably rendered in body
// Handle head[0] - viewport
if (isDeferredRsc(head)) {
head.resolve(dynamicHead)
}
......
......@@ -62,6 +62,7 @@ export interface ExportPageInput {
nextConfigOutput?: NextConfigComplete['output']
enableExperimentalReact?: boolean
sriEnabled: boolean
streamingMetadata: boolean | undefined
}
export type ExportRouteResult =
......
......@@ -253,6 +253,13 @@ async function exportPageImpl(
)
}
// During the export phase in next build, if it's using PPR we can serve streaming metadata
// when it's available. When we're building the PPR rendering result, we don't need to rely
// on the user agent. The result can be determined to serve streaming on infrastructure level.
const serveStreamingMetadata = Boolean(
isRoutePPREnabled && input.streamingMetadata
)
const renderOpts: WorkerRenderOpts = {
...components,
...input.renderOpts,
......@@ -262,6 +269,7 @@ async function exportPageImpl(
disableOptimizedLoading,
locale,
supportsDynamicResponse: false,
serveStreamingMetadata,
experimental: {
...input.renderOpts.experimental,
isRoutePPREnabled,
......@@ -416,6 +424,7 @@ export async function exportPages(
debugOutput: options.debugOutput,
enableExperimentalReact: needsExperimentalReact(nextConfig),
sriEnabled: Boolean(nextConfig.experimental.sri?.algorithm),
streamingMetadata: nextConfig.experimental.streamingMetadata,
buildId: input.buildId,
}),
// If exporting the page takes longer than the timeout, reject the promise.
......
'use client'
import { use } from 'react'
import { useServerInsertedHTML } from '../../client/components/navigation'
import { use, type JSX } from 'react'
import { useServerInsertedMetadata } from '../../server/app-render/metadata-insertion/use-server-inserted-metadata'
// We need to wait for metadata on server once it's resolved, and insert into
// the HTML through `useServerInsertedHTML`. It will suspense in <head> during SSR.
function ServerInsertMetadata({ promise }: { promise: Promise<any> }) {
let metadataToFlush: React.ReactNode = use(promise)
useServerInsertedHTML(() => {
if (metadataToFlush) {
const flushing = metadataToFlush
// reset to null to ensure we only flush it once
metadataToFlush = null
return flushing
}
})
function ServerInsertMetadata({ promise }: { promise: Promise<JSX.Element> }) {
// Apply use() to the metadata promise to suspend the rendering in SSR.
const metadata = use(promise)
// Insert metadata into the HTML stream through the `useServerInsertedMetadata`
useServerInsertedMetadata(() => metadata)
return null
}
......
......@@ -3,7 +3,7 @@ import type { GetDynamicParamFromSegment } from '../../server/app-render/app-ren
import type { LoaderTree } from '../../server/lib/app-dir-module'
import type { CreateServerParamsForMetadata } from '../../server/request/params'
import { cache, cloneElement } from 'react'
import { Suspense, cache, cloneElement } from 'react'
import {
AppleWebAppMeta,
FormatDetectionMeta,
......@@ -38,6 +38,7 @@ import {
VIEWPORT_BOUNDARY_NAME,
} from './metadata-constants'
import { AsyncMetadata } from './async-metadata'
import { isPostpone } from '../../server/lib/router-utils/is-postpone'
// Use a promise to share the status of the metadata resolving,
// returning two components `MetadataTree` and `MetadataOutlet`
......@@ -147,8 +148,8 @@ export function createMetadataComponents({
async function resolveFinalMetadata() {
try {
return await metadata()
} catch (error) {
if (!errorType && isHTTPAccessFallbackError(error)) {
} catch (metadataErr) {
if (!errorType && isHTTPAccessFallbackError(metadataErr)) {
try {
return await getNotFoundMetadata(
tree,
......@@ -158,7 +159,18 @@ export function createMetadataComponents({
createServerParamsForMetadata,
workStore
)
} catch {}
} catch (notFoundMetadataErr) {
// In PPR rendering we still need to throw the postpone error.
// If metadata is postponed, React needs to be aware of the location of error.
if (isPostpone(notFoundMetadataErr)) {
throw notFoundMetadataErr
}
}
}
// In PPR rendering we still need to throw the postpone error.
// If metadata is postponed, React needs to be aware of the location of error.
if (isPostpone(metadataErr)) {
throw metadataErr
}
// We don't actually want to error in this component. We will
// also error in the MetadataOutlet which causes the error to
......@@ -168,10 +180,15 @@ export function createMetadataComponents({
}
}
async function Metadata() {
const promise = resolveFinalMetadata()
if (serveStreamingMetadata) {
return <AsyncMetadata promise={resolveFinalMetadata()} />
return (
<Suspense fallback={null}>
<AsyncMetadata promise={promise} />
</Suspense>
)
}
return await resolveFinalMetadata()
return await promise
}
Metadata.displayName = METADATA_BOUNDARY_NAME
......
import React, { type JSX } from 'react'
import { renderToReadableStream } from 'react-dom/server.edge'
import {
ServerInsertedMetadataContext,
type MetadataResolver,
} from '../../../shared/lib/server-inserted-metadata.shared-runtime'
import { renderToString } from '../render-to-string'
export function createServerInsertedMetadata() {
let metadataResolver: MetadataResolver | null = null
let metadataToFlush: JSX.Element | null = null
const setMetadataResolver = (resolver: MetadataResolver): void => {
metadataResolver = resolver
}
return {
ServerInsertedMetadataProvider: ({
children,
}: {
children: React.ReactNode
}) => {
return (
<ServerInsertedMetadataContext.Provider value={setMetadataResolver}>
{children}
</ServerInsertedMetadataContext.Provider>
)
},
async getServerInsertedMetadata(): Promise<string> {
if (!metadataResolver || metadataToFlush) {
return ''
}
metadataToFlush = metadataResolver()
const html = await renderToString({
renderToReadableStream,
element: <>{metadataToFlush}</>,
})
return html
},
}
}
'use client'
import { useContext } from 'react'
import {
type MetadataResolver,
ServerInsertedMetadataContext,
} from '../../../shared/lib/server-inserted-metadata.shared-runtime'
// Receives a metadata resolver setter from the context, and will pass the metadata resolving promise to
// the context where we gonna use it to resolve the metadata, and render as string to append in <body>.
export const useServerInsertedMetadata = (
metadataResolver: MetadataResolver
) => {
const setMetadataResolver = useContext(ServerInsertedMetadataContext)
if (setMetadataResolver) {
setMetadataResolver(metadataResolver)
}
}
import { streamToString } from '../stream-utils/node-web-streams-helper'
import { AppRenderSpan } from '../lib/trace/constants'
import { getTracer } from '../lib/trace/tracer'
export async function renderToString({
ReactDOMServer,
renderToReadableStream,
element,
}: {
ReactDOMServer: typeof import('react-dom/server.edge')
// `renderToReadableStream()` method could come from different react-dom/server implementations
// such as `react-dom/server.edge` or `react-dom/server.node`, etc.
renderToReadableStream: typeof import('react-dom/server.edge').renderToReadableStream
element: React.ReactElement
}) {
return getTracer().trace(AppRenderSpan.renderToString, async () => {
const renderStream = await ReactDOMServer.renderToReadableStream(element)
await renderStream.allReady
return streamToString(renderStream)
})
}): Promise<string> {
const renderStream = await renderToReadableStream(element)
await renderStream.allReady
return streamToString(renderStream)
}
......@@ -177,6 +177,7 @@ export interface RenderOptsPartial {
assetPrefix?: string
crossOrigin?: '' | 'anonymous' | 'use-credentials' | undefined
nextFontManifest?: DeepReadonly<NextFontManifest>
botType?: 'dom' | 'html' | undefined
serveStreamingMetadata?: boolean
incrementalCache?: import('../lib/incremental-cache').IncrementalCache
cacheLifeProfiles?: {
......@@ -220,6 +221,12 @@ export interface RenderOptsPartial {
}
postponed?: string
/**
* Should wait for react stream allReady to resolve all suspense boundaries,
* in order to perform a full page render.
*/
shouldWaitOnAllReady?: boolean
/**
* The resume data cache that was generated for this partially prerendered
* page during dev warmup.
......
......@@ -83,7 +83,7 @@ import {
} from './lib/revalidate'
import { execOnce } from '../shared/lib/utils'
import { isBlockedPage } from './utils'
import { isBot } from '../shared/lib/router/utils/is-bot'
import { getBotType, isBot } from '../shared/lib/router/utils/is-bot'
import RenderResult from './render-result'
import { removeTrailingSlash } from '../shared/lib/router/utils/remove-trailing-slash'
import { denormalizePagePath } from '../shared/lib/page-path/denormalize-page-path'
......@@ -175,8 +175,11 @@ import type { RouteModule } from './route-modules/route-module'
import { FallbackMode, parseFallbackField } from '../lib/fallback'
import { toResponseCacheEntry } from './response-cache/utils'
import { scheduleOnNextTick } from '../lib/scheduler'
import { shouldServeStreamingMetadata } from './lib/streaming-metadata'
import { SegmentPrefixRSCPathnameNormalizer } from './normalizers/request/segment-prefix-rsc'
import {
shouldServeStreamingMetadata,
isHtmlBotRequestStreamingMetadata,
} from './lib/streaming-metadata'
export type FindComponentsResult = {
components: LoadComponentsReturnType
......@@ -1761,6 +1764,7 @@ export default abstract class Server<
renderOpts: {
...this.renderOpts,
supportsDynamicResponse: !isBotRequest,
botType: getBotType(ua),
serveStreamingMetadata: shouldServeStreamingMetadata(
ua,
this.renderOpts.experimental
......@@ -2064,6 +2068,14 @@ export default abstract class Server<
}
}
const isHtmlBotRequest = isHtmlBotRequestStreamingMetadata(
req,
this.renderOpts.experimental.streamingMetadata
)
if (isHtmlBotRequest) {
this.renderOpts.serveStreamingMetadata = false
}
if (
hasFallback ||
staticPaths?.includes(resolvedUrlPathname) ||
......@@ -2072,6 +2084,10 @@ export default abstract class Server<
req.headers['x-now-route-matches']
) {
isSSG = true
} else if (isHtmlBotRequest) {
// When it's html limited bots request, disable SSG
// and perform the full blocking rendering.
isSSG = false
} else if (!this.renderOpts.dev) {
isSSG ||= !!prerenderManifest.routes[toRoute(pathname)]
}
......@@ -2474,6 +2490,8 @@ export default abstract class Server<
// make sure to only add query values from original URL
query: origQuery,
})
const shouldWaitOnAllReady = !supportsDynamicResponse || isHtmlBotRequest
const renderOpts: LoadedRenderOpts = {
...components,
...opts,
......@@ -2511,6 +2529,7 @@ export default abstract class Server<
isRoutePPREnabled,
},
supportsDynamicResponse,
shouldWaitOnAllReady,
isOnDemandRevalidate,
isDraftMode: isPreviewMode,
isServerAction,
......@@ -3527,7 +3546,7 @@ export default abstract class Server<
}
// Mark that the request did postpone.
if (didPostpone) {
if (didPostpone && !isHtmlBotRequest) {
res.setHeader(NEXT_DID_POSTPONE_HEADER, '1')
}
......
import { HTML_LIMITED_BOT_UA_RE_STRING } from '../../shared/lib/router/utils/is-bot'
import {
getBotType,
HTML_LIMITED_BOT_UA_RE_STRING,
} from '../../shared/lib/router/utils/is-bot'
import type { BaseNextRequest } from '../base-http'
export function shouldServeStreamingMetadata(
userAgent: string,
......@@ -23,3 +27,15 @@ export function shouldServeStreamingMetadata(
!!userAgent && !blockingMetadataUARegex.test(userAgent)
)
}
// When streaming metadata is enabled and request UA is a html-limited bot, we should do a dynamic render.
// In this case, postpone state is not sent.
export function isHtmlBotRequestStreamingMetadata(
req: BaseNextRequest,
streamingMetadata: boolean
): boolean {
const ua = req.headers['user-agent'] || ''
const botType = getBotType(ua)
return botType === 'html' && streamingMetadata
}
......@@ -266,6 +266,7 @@ export type RenderOptsPartial = {
domainLocales?: readonly DomainLocale[]
disableOptimizedLoading?: boolean
supportsDynamicResponse: boolean
botType?: 'dom' | 'html' | undefined
serveStreamingMetadata?: boolean
runtime?: ServerRuntime
serverComponents?: boolean
......
export * as HeadManagerContext from '../../../../../shared/lib/head-manager-context.shared-runtime'
export * as ServerInsertedHtml from '../../../../../shared/lib/server-inserted-html.shared-runtime'
export * as ServerInsertedMetadata from '../../../../../shared/lib/server-inserted-metadata.shared-runtime'
export * as AppRouterContext from '../../../../../shared/lib/app-router-context.shared-runtime'
export * as HooksClientContext from '../../../../../shared/lib/hooks-client-context.shared-runtime'
export * as RouterContext from '../../../../../shared/lib/router-context.shared-runtime'
......
module.exports = require('../../module.compiled').vendored[
'contexts'
].ServerInsertedMetadata
......@@ -523,6 +523,7 @@ export type ContinueStreamOptions = {
inlinedDataStream: ReadableStream<Uint8Array> | undefined
isStaticGeneration: boolean
getServerInsertedHTML: () => Promise<string>
getServerInsertedMetadata: () => Promise<string>
validateRootLayout?: boolean
/**
* Suffix to inject after the buffered data, but before the close tags.
......@@ -537,6 +538,7 @@ export async function continueFizzStream(
inlinedDataStream,
isStaticGeneration,
getServerInsertedHTML,
getServerInsertedMetadata,
validateRootLayout,
}: ContinueStreamOptions
): Promise<ReadableStream<Uint8Array>> {
......@@ -553,6 +555,9 @@ export async function continueFizzStream(
// Buffer everything to avoid flushing too frequently
createBufferedTransformStream(),
// Insert generated metadata
createHeadInsertionTransformStream(getServerInsertedMetadata),
// Insert suffix content
suffixUnclosed != null && suffixUnclosed.length > 0
? createDeferredSuffixStream(suffixUnclosed)
......@@ -576,11 +581,15 @@ export async function continueFizzStream(
type ContinueDynamicPrerenderOptions = {
getServerInsertedHTML: () => Promise<string>
getServerInsertedMetadata: () => Promise<string>
}
export async function continueDynamicPrerender(
prerenderStream: ReadableStream<Uint8Array>,
{ getServerInsertedHTML }: ContinueDynamicPrerenderOptions
{
getServerInsertedHTML,
getServerInsertedMetadata,
}: ContinueDynamicPrerenderOptions
) {
return (
prerenderStream
......@@ -589,17 +598,26 @@ export async function continueDynamicPrerender(
.pipeThrough(createStripDocumentClosingTagsTransform())
// Insert generated tags to head
.pipeThrough(createHeadInsertionTransformStream(getServerInsertedHTML))
// Insert generated metadata
.pipeThrough(
createHeadInsertionTransformStream(getServerInsertedMetadata)
)
)
}
type ContinueStaticPrerenderOptions = {
inlinedDataStream: ReadableStream<Uint8Array>
getServerInsertedHTML: () => Promise<string>
getServerInsertedMetadata: () => Promise<string>
}
export async function continueStaticPrerender(
prerenderStream: ReadableStream<Uint8Array>,
{ inlinedDataStream, getServerInsertedHTML }: ContinueStaticPrerenderOptions
{
inlinedDataStream,
getServerInsertedHTML,
getServerInsertedMetadata,
}: ContinueStaticPrerenderOptions
) {
return (
prerenderStream
......@@ -607,6 +625,10 @@ export async function continueStaticPrerender(
.pipeThrough(createBufferedTransformStream())
// Insert generated tags to head
.pipeThrough(createHeadInsertionTransformStream(getServerInsertedHTML))
// Insert generated metadata to head
.pipeThrough(
createHeadInsertionTransformStream(getServerInsertedMetadata)
)
// Insert the inlined data (Flight data, form state, etc.) stream into the HTML
.pipeThrough(createMergedTransformStream(inlinedDataStream))
// Close tags should always be deferred to the end
......@@ -617,11 +639,16 @@ export async function continueStaticPrerender(
type ContinueResumeOptions = {
inlinedDataStream: ReadableStream<Uint8Array>
getServerInsertedHTML: () => Promise<string>
getServerInsertedMetadata: () => Promise<string>
}
export async function continueDynamicHTMLResume(
renderStream: ReadableStream<Uint8Array>,
{ inlinedDataStream, getServerInsertedHTML }: ContinueResumeOptions
{
inlinedDataStream,
getServerInsertedHTML,
getServerInsertedMetadata,
}: ContinueResumeOptions
) {
return (
renderStream
......@@ -629,6 +656,10 @@ export async function continueDynamicHTMLResume(
.pipeThrough(createBufferedTransformStream())
// Insert generated tags to head
.pipeThrough(createHeadInsertionTransformStream(getServerInsertedHTML))
// Insert generated metadata to body
.pipeThrough(
createHeadInsertionTransformStream(getServerInsertedMetadata)
)
// Insert the inlined data (Flight data, form state, etc.) stream into the HTML
.pipeThrough(createMergedTransformStream(inlinedDataStream))
// Close tags should always be deferred to the end
......
......@@ -12,7 +12,7 @@ export const HTML_LIMITED_BOT_UA_RE = new RegExp(
'i'
)
function isHeadlessBrowserBotUA(userAgent: string) {
function isDomBotUA(userAgent: string) {
return HEADLESS_BROWSER_BOT_UA_RE.test(userAgent)
}
......@@ -21,5 +21,15 @@ function isHtmlLimitedBotUA(userAgent: string) {
}
export function isBot(userAgent: string): boolean {
return isHeadlessBrowserBotUA(userAgent) || isHtmlLimitedBotUA(userAgent)
return isDomBotUA(userAgent) || isHtmlLimitedBotUA(userAgent)
}
export function getBotType(userAgent: string): 'dom' | 'html' | undefined {
if (isDomBotUA(userAgent)) {
return 'dom'
}
if (isHtmlLimitedBotUA(userAgent)) {
return 'html'
}
return undefined
}
'use client'
import { type JSX, createContext } from 'react'
export type MetadataResolver = () => JSX.Element
type MetadataResolverSetter = (m: MetadataResolver) => void
export const ServerInsertedMetadataContext =
createContext<MetadataResolverSetter | null>(null)
......@@ -7,15 +7,10 @@ describe('app-dir - metadata-static-generation', () => {
files: __dirname,
})
// /suspenseful/dynamic will behave differently when PPR is enabled.
// We'll visit PPR tests in the new test suite.
if (isPPREnabled) {
it('skip ppr test', () => {})
return
}
if (isNextStart) {
// Precondition for the following tests in build mode
if (isNextStart && !isPPREnabled) {
// Precondition for the following tests in build mode.
// This test is only useful for non-PPR mode as in PPR mode those routes
// are all listed in the prerender manifest.
it('should generate all pages static', async () => {
const prerenderManifest = JSON.parse(
await next.readFile('.next/prerender-manifest.json')
......
import Link from 'next/link'
import { ReactNode } from 'react'
const hrefs = [
'/slow/dynamic',
'/slow/static',
'/',
'/suspenseful/dynamic',
'/suspenseful/static',
]
export default function Root({ children }: { children: ReactNode }) {
return (
<html>
<body>
<div>
<Link href="/slow" id="to-slow">
{`to /slow`}
</Link>
<br />
<Link href="/" id="to-home">
{`to /`}
</Link>
<br />
<Link href="/suspenseful/dynamic" id="to-suspenseful-dynamic">
{`to /suspenseful/dynamic`}
</Link>
<br />
<Link href="/suspenseful/static" id="to-suspenseful-static">
{`to /suspenseful/static`}
</Link>
{hrefs.map((href) => (
<div key={href}>
<Link href={href} id={`to-${href.replace('/', '')}`}>
{`to ${href}`}
</Link>
<br />
</div>
))}
</div>
{children}
</body>
......
......@@ -7,15 +7,10 @@ describe('app-dir - metadata-streaming-static-generation', () => {
files: __dirname,
})
// /suspenseful/dynamic will behave differently when PPR is enabled.
// We'll visit PPR tests in the new test suite.
if (isPPREnabled) {
it('skip ppr test', () => {})
return
}
if (isNextStart) {
// Precondition for the following tests in build mode
if (isNextStart && !isPPREnabled) {
// Precondition for the following tests in build mode.
// This test is only useful for non-PPR mode as in PPR mode those routes
// are all listed in the prerender manifest.
it('should generate all pages static', async () => {
const prerenderManifest = JSON.parse(
await next.readFile('.next/prerender-manifest.json')
......
......@@ -73,7 +73,7 @@ describe('app-dir - metadata-streaming', () => {
})
})
it('should not insert metadata twice or inject into body', async () => {
it('should only insert metadata once into head or body', async () => {
const browser = await next.browser('/slow')
// each metadata should be inserted only once
......
import { connection } from 'next/server'
export default function Home() {
return (
<div>
<h1>Dynamic Metadata</h1>
</div>
)
}
export async function generateMetadata() {
await connection()
await new Promise((resolve) => setTimeout(resolve, 2 * 1000))
return {
title: `dynamic metadata`,
description: `dynamic metadata - ${Math.random()}`,
}
}
import { Suspense } from 'react'
export default function Layout({ children }) {
return (
<div>
<h2>Suspenseful Layout</h2>
<Suspense>{children}</Suspense>
</div>
)
}
import { connection } from 'next/server'
// Page is suspended and being caught by the layout Suspense boundary
export default function Page() {
return (
<div className="container">
<SuspendedComponent />
</div>
)
}
async function SuspendedComponent() {
await connection()
await new Promise((resolve) => setTimeout(resolve, 500))
return (
<div>
<div>suspended component</div>
<NestedSuspendedComponent />
</div>
)
}
async function NestedSuspendedComponent() {
await connection()
await new Promise((resolve) => setTimeout(resolve, 500))
return <div>nested suspended component</div>
}
export async function generateMetadata() {
await connection()
await new Promise((resolve) => setTimeout(resolve, 3 * 1000))
return {
title: 'dynamic-metadata - partial',
description: `dynamic metadata - ${Math.random()}`,
}
}
import { headers } from 'next/headers'
// Dynamic usage in page, wrapped with Suspense boundary
export default function Page() {
return (
<div>
<h1>Dynamic Page</h1>
<SubComponent />
</div>
)
}
async function SubComponent() {
await headers()
return <div>Dynamic Headers</div>
}
export async function generateMetadata() {
// Slow but static metadata
await new Promise((resolve) => setTimeout(resolve, 2 * 1000))
return {
title: `dynamic page`,
}
}
import { Suspense } from 'react'
export default function Layout({ children }) {
return (
<div data-date={Number(new Date())}>
<h2>Suspenseful Layout</h2>
<Suspense>{children}</Suspense>
</div>
)
}
import { connection } from 'next/server'
/// Page is suspended and being caught by the layout Suspense boundary
export default function Page() {
return (
<div className="container">
<SuspendedComponent />
</div>
)
}
async function SuspendedComponent() {
await connection()
await new Promise((resolve) => setTimeout(resolve, 500))
return (
<div>
<div>suspended component</div>
<NestedSuspendedComponent />
</div>
)
}
async function NestedSuspendedComponent() {
await connection()
await new Promise((resolve) => setTimeout(resolve, 500))
return <div>nested suspended component</div>
}
export async function generateMetadata() {
// Slow but static metadata
await new Promise((resolve) => setTimeout(resolve, 2 * 1000))
return {
title: 'dynamic-page - partial',
}
}
import { cookies } from 'next/headers'
import { connection } from 'next/server'
import { Suspense } from 'react'
export default function Home() {
return (
<div>
<h1>Fully Dynamic</h1>
<Suspense>
<SubComponent />
</Suspense>
</div>
)
}
async function SubComponent() {
const cookieStore = await cookies()
await new Promise((resolve) => setTimeout(resolve, 500))
const cookie = await cookieStore.get('test')
return <div>Cookie: {cookie?.value}</div>
}
export async function generateMetadata() {
await connection()
await new Promise((resolve) => setTimeout(resolve, 2 * 1000))
return {
title: `fully dynamic`,
description: `fully dynamic - ${Math.random()}`,
}
}
export default function Page() {
return <p>slow</p>
}
export async function generateMetadata() {
await new Promise((resolve) => setTimeout(resolve, 2 * 1000))
return {
title: 'fully static',
description: 'fully static',
}
}
import Link from 'next/link'
import { ReactNode } from 'react'
const hrefs = [
'/dynamic-metadata',
'/dynamic-metadata/partial',
'/dynamic-page',
'/dynamic-page/partial',
'/fully-dynamic',
'/fully-static',
]
export default function Root({ children }: { children: ReactNode }) {
return (
<html>
<body>
<div>
{hrefs.map((href) => (
<div key={href}>
<Link href={href} id={`to-${href}`} prefetch={false}>
{`to ${href}`}
</Link>
</div>
))}
</div>
{children}
</body>
</html>
)
}
/**
* @type {import('next').NextConfig}
*/
const nextConfig = {
experimental: {
ppr: true,
streamingMetadata: true,
},
}
module.exports = nextConfig
import { nextTestSetup } from 'e2e-utils'
import cheerio from 'cheerio'
import { assertNoConsoleErrors } from 'next-test-utils'
function countSubstring(str: string, substr: string): number {
return str.split(substr).length - 1
}
describe('ppr-metadata-streaming', () => {
const { next, isNextDev, isNextStart, isNextDeploy } = nextTestSetup({
files: __dirname,
})
// No dynamic APIs used in metadata
describe('static metadata', () => {
it('should generate metadata in head when page is fully static', async () => {
const rootSelector = isNextDev ? 'body' : 'head'
const $ = await next.render$('/fully-static')
expect($(`${rootSelector} title`).text()).toBe('fully static')
expect(countSubstring($.html(), '<title>')).toBe(1)
const browser = await next.browser('/fully-static')
expect(
await browser.waitForElementByCss(`${rootSelector} title`).text()
).toBe('fully static')
await assertNoConsoleErrors(browser)
})
it('should insert metadata in body when page is dynamic page content', async () => {
const $ = await next.render$('/dynamic-page')
expect($(`body title`).text()).toBe('dynamic page')
expect(countSubstring($.html(), '<title>')).toBe(1)
const browser = await next.browser('/dynamic-page')
expect(await browser.waitForElementByCss('body title').text()).toBe(
'dynamic page'
)
await assertNoConsoleErrors(browser)
})
})
// Dynamic APIs used in metadata, metadata should be suspended and inserted into body
describe('dynamic metadata', () => {
it('should generate metadata in body when page is fully dynamic', async () => {
const $ = await next.render$('/fully-dynamic')
expect($('body title').text()).toBe('fully dynamic')
expect(countSubstring($.html(), '<title>')).toBe(1)
const browser = await next.browser('/fully-dynamic')
expect(await browser.waitForElementByCss('body title').text()).toBe(
'fully dynamic'
)
await assertNoConsoleErrors(browser)
})
it('should generate metadata in body when page content is static', async () => {
const $ = await next.render$('/dynamic-metadata')
expect($('body title').text()).toBe('dynamic metadata')
expect(countSubstring($.html(), '<title>')).toBe(1)
const browser = await next.browser('/dynamic-metadata')
expect(await browser.waitForElementByCss('body title').text()).toBe(
'dynamic metadata'
)
await assertNoConsoleErrors(browser)
})
})
describe('partial shell', () => {
it('should insert metadata into body with dynamic metadata and wrapped under layout Suspense boundary', async () => {
const $ = await next.render$('/dynamic-metadata/partial')
expect($('body title').text()).toBe('dynamic-metadata - partial')
expect(countSubstring($.html(), '<title>')).toBe(1)
const browser = await next.browser('/dynamic-metadata/partial')
expect(await browser.waitForElementByCss('body title').text()).toBe(
'dynamic-metadata - partial'
)
await assertNoConsoleErrors(browser)
})
it('should insert metadata into head with dynamic metadata and dynamic page wrapped under layout Suspense boundary', async () => {
const rootSelector = isNextDev ? 'body' : 'head'
const $ = await next.render$('/dynamic-page/partial')
expect($(`${rootSelector} title`).text()).toBe('dynamic-page - partial')
expect(countSubstring($.html(), '<title>')).toBe(1)
const browser = await next.browser('/dynamic-page/partial')
expect(
await browser.waitForElementByCss(`${rootSelector} title`).text()
).toBe('dynamic-page - partial')
await assertNoConsoleErrors(browser)
})
})
// Disable deployment until we support it on infra
if (isNextStart && !isNextDeploy) {
// This test is only relevant in production mode, as it's testing PPR results
describe('html limited bots', () => {
it('should serve partial static shell when normal UA requests the page', async () => {
const res1 = await next.fetch('/dynamic-page/partial')
const res2 = await next.fetch('/dynamic-page/partial')
const $1 = cheerio.load(await res1.text())
const $2 = cheerio.load(await res2.text())
const attribute1 = parseInt($1('[data-date]').attr('data-date'))
const attribute2 = parseInt($2('[data-date]').attr('data-date'))
// Normal UA should still get the partial static shell produced by PPR
expect(attribute1).toBe(attribute2)
expect(attribute1).toBeTruthy()
const headers = res1.headers
// Static render should have postponed header
expect(headers.get('x-nextjs-postponed')).toBe('1')
})
it('should not serve partial static shell when html limited bots requests the page', async () => {
const htmlLimitedBotUA = 'Discordbot'
const res1 = await next.fetch('/dynamic-page/partial', {
headers: {
'User-Agent': htmlLimitedBotUA,
},
})
const res2 = await next.fetch('/dynamic-page/partial', {
headers: {
'User-Agent': htmlLimitedBotUA,
},
})
// Dynamic render should not have postponed header
const headers = res1.headers
expect(headers.get('x-nextjs-postponed')).toBe(null)
const $1 = cheerio.load(await res1.text())
const $2 = cheerio.load(await res2.text())
const attribute1 = parseInt($1('[data-date]').attr('data-date'))
const attribute2 = parseInt($2('[data-date]').attr('data-date'))
// Two requests are dynamic and should not have the same data-date attribute
expect(attribute2).toBeGreaterThan(attribute1)
expect(attribute1).toBeTruthy()
})
})
}
})
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment