FilesExpand file tree

main

/

render-page.ts

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

193 lines (163 loc) · 7.06 KB

main

/

render-page.ts

Copy path

Top

File metadata and controls

• Code
• Blame

193 lines (163 loc) · 7.06 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

import type { Response } from 'express'

import type { Failbot } from '@github/failbot'

import { get } from 'lodash-es'

import { createLogger } from '@/observability/logger'

import { buildMiniTocFromCollected, type CollectedHeading } from '@/frame/lib/get-mini-toc-items'

import patterns from '@/frame/lib/patterns'

import FailBot from '@/observability/lib/failbot'

import statsd, { adaptForTimer } from '@/observability/lib/statsd'

import type { ExtendedRequest } from '@/types'

import { allVersions } from '@/versions/lib/all-versions'

import { transformerRegistry } from '@/article-api/transformers'

import { normalizeRenderedMarkdown } from '@/article-api/lib/normalize-markdown'

import { renderContentToHast } from '@/content-render/index'

import { minimumNotFoundHtml } from '../lib/constants'

import { contentTypeCacheControl, defaultCacheControl } from './cache-control'

import { nextHandleRequest } from './next'

const logger = createLogger(import.meta.url)

const STATSD_KEY_RENDER = 'middleware.render_page'

async function buildRenderedPage(req: ExtendedRequest): Promise<string> {

const { context } = req

if (!context) throw new Error('request not contextualized')

const { page } = context

if (!page) throw new Error('page not set in context')

const path = req.pagePath || req.path

// Collect mini-TOC headings only for pages that show one, so other renders avoid plugin work.

if (page.showMiniToc) {

const collectMiniToc: CollectedHeading[] = []

context.collectMiniToc = collectMiniToc

}

const pageRenderTimed = statsd.asyncTimer(adaptForTimer(page.render), STATSD_KEY_RENDER, [

`path:${path}`,

])

return (await pageRenderTimed(context)) as string

}

// buildRenderedPageHast returns a serializable HTML AST alongside renderedPage.

// It runs after buildRenderedPage because page.render populates englishHeadings and alertTitles.

// It disables collectMiniToc so mini-TOC collection does not repeat.

// Failures return undefined, and the React layer falls back to renderedPage.

async function buildRenderedPageHast(req: ExtendedRequest) {

const { context } = req

if (!context) throw new Error('request not contextualized')

const { page } = context

if (!page || !page.markdown) return undefined

try {

const hastContext = { ...context, collectMiniToc: undefined }

const { hast, html } = await renderContentToHast(page.markdown, hastContext)

// A whitespace-only body yields an empty root, which consumers would treat as content.

return hast && html.trim() ? hast : undefined

} catch (error) {

logger.error(

'buildRenderedPageHast failed; falling back to string path',

error instanceof Error ? error : new Error(String(error)),

{ path: req.pagePath || req.path },

)

return undefined

}

}

function buildMiniTocItems(req: ExtendedRequest) {

const { context } = req

if (!context) throw new Error('request not contextualized')

const { page } = context

if (!page || !page.showMiniToc) {

return

}

// Collected headings avoid rendering article content a second time.

const collected = context.collectMiniToc as CollectedHeading[] | undefined

if (collected) {

return buildMiniTocFromCollected(collected, 2)

}

}

export default async function renderPage(req: ExtendedRequest, res: Response) {

const { context } = req

// Next.js Error.getInitialProps reads req.FailBot so it can report errors to Failbot.

req.FailBot = FailBot as Failbot

if (!context) throw new Error('request not contextualized')

const { page } = context

const path = req.pagePath || req.path

if (!page) {

if (process.env.NODE_ENV !== 'test' && context.redirectNotFound) {

logger.error('Tried to redirect to a page that was not found', {

redirectNotFound: context.redirectNotFound,

})

}

// Passing this context to App Router 404 handling causes hydration failures.

defaultCacheControl(res)

return res.status(404).type('html').send(minimumNotFoundHtml)

}

// HEAD skips page rendering but still lets Express send Content-Length: 0.

if (req.method === 'HEAD') {

return res.status(200).send('')

}

// effectiveDate marks substantive page changes for clients that watch Last-Modified.

if (page.effectiveDate) {

// ArticleContext turns unparseable effectiveDate strings into a 500.

res.setHeader('Last-Modified', new Date(page.effectiveDate).toUTCString())

}

// Serve markdown when the client prefers it over HTML; agents can omit text/html.

if (req.accepts(['text/html', 'text/markdown']) === 'text/markdown') {

context.markdownRequested = true

}

if (!req.context) throw new Error('request not contextualized')

if (context.markdownRequested) {

const transformer = transformerRegistry.findTransformer(page)

if (!transformer) throw new Error(`No transformer found for page: ${req.pagePath}`)

// Clear markdownRequested so renderTitle and renderProp output HTML for stripOuterTag.

const transformerContext = { ...context, markdownRequested: false }

req.context.renderedPage = normalizeRenderedMarkdown(

await transformer.transform(page, path, transformerContext),

)

} else {

req.context.renderedPage = await buildRenderedPage(req)

req.context.renderedPageHast = await buildRenderedPageHast(req)

req.context.miniTocItems = buildMiniTocItems(req)

}

page.fullTitle = page.title

if (!patterns.homepagePath.test(path)) {

if (

req.context.currentVersion === 'free-pro-team@latest' ||

!allVersions[req.context.currentVersion!]

) {

page.fullTitle += ` - ${get(context.site!.data.ui, 'header.github_docs')}`

} else {

const { versionTitle } = allVersions[req.context.currentVersion!]

page.fullTitle += ' - '

// Prefix version titles that omit GitHub.

if (!versionTitle.includes('GitHub')) {

page.fullTitle += 'GitHub '

}

page.fullTitle += `${versionTitle} Docs`

}

}

const isRequestingJsonForDebugging = 'json' in req.query && process.env.NODE_ENV !== 'production'

if (isRequestingJsonForDebugging) {

const json = req.query.json

if (Array.isArray(json)) {

// Example: ?json=page.permalinks&json=currentPath.

throw new Error("'json' query string can only be 1")

}

if (json) {

// Example deep reference: ?json=page.permalinks.

return res.json(get(context, req.query.json as string))

} else {

// Example full key dump: ?json.

return res.json({

message:

'The full context object is too big to display! Try one of the individual keys below, e.g. ?json=page. You can also access nested props like ?json=site.data.reusables',

keys: Object.keys(context),

})

}

}

if (context.markdownRequested) {

if (context.markdownViaUrl) {

// A .md URL suffix always returns markdown, so Vary: accept would mislead.

defaultCacheControl(res)

} else {

// The Accept header picks the representation, so Vary: accept is correct.

contentTypeCacheControl(res)

}

return res.type('text/markdown').send(req.context.renderedPage)

}

contentTypeCacheControl(res)

return nextHandleRequest(req, res)

}