| import { execSync, spawn } from 'child_process' |
| import { join } from 'path' |
| import { fileURLToPath } from 'url' |
| import fetch from 'node-fetch' |
| import { |
| existsSync, |
| readFileSync, |
| writeFileSync, |
| unlinkSync, |
| promises as fs, |
| } from 'fs' |
| import prettyMs from 'pretty-ms' |
| import treeKill from 'tree-kill' |
|
|
| const ROOT_DIR = join(fileURLToPath(import.meta.url), '..', '..', '..') |
| const CWD = join(ROOT_DIR, 'bench', 'nested-deps-app-router') |
|
|
| const NEXT_BIN = join(ROOT_DIR, 'packages', 'next', 'dist', 'bin', 'next') |
|
|
| const [, , command = 'all'] = process.argv |
|
|
| async function killApp(instance) { |
| await new Promise((resolve, reject) => { |
| treeKill(instance.pid, (err) => { |
| if (err) { |
| if ( |
| process.platform === 'win32' && |
| typeof err.message === 'string' && |
| (err.message.includes(`no running instance of the task`) || |
| err.message.includes(`not found`)) |
| ) { |
| |
| |
| |
| |
| |
| return resolve() |
| } |
| return reject(err) |
| } |
|
|
| resolve() |
| }) |
| }) |
| } |
|
|
| class File { |
| constructor(path) { |
| this.path = path |
| this.originalContent = existsSync(this.path) |
| ? readFileSync(this.path, 'utf8') |
| : null |
| } |
|
|
| write(content) { |
| if (!this.originalContent) { |
| this.originalContent = content |
| } |
| writeFileSync(this.path, content, 'utf8') |
| } |
|
|
| replace(pattern, newValue) { |
| const currentContent = readFileSync(this.path, 'utf8') |
| if (pattern instanceof RegExp) { |
| if (!pattern.test(currentContent)) { |
| throw new Error( |
| `Failed to replace content.\n\nPattern: ${pattern.toString()}\n\nContent: ${currentContent}` |
| ) |
| } |
| } else if (typeof pattern === 'string') { |
| if (!currentContent.includes(pattern)) { |
| throw new Error( |
| `Failed to replace content.\n\nPattern: ${pattern}\n\nContent: ${currentContent}` |
| ) |
| } |
| } else { |
| throw new Error(`Unknown replacement attempt type: ${pattern}`) |
| } |
|
|
| const newContent = currentContent.replace(pattern, newValue) |
| this.write(newContent) |
| } |
|
|
| prepend(line) { |
| const currentContent = readFileSync(this.path, 'utf8') |
| this.write(line + '\n' + currentContent) |
| } |
|
|
| delete() { |
| unlinkSync(this.path) |
| } |
|
|
| restore() { |
| this.write(this.originalContent) |
| } |
| } |
|
|
| function runNextCommandDev(argv, opts = {}) { |
| const env = { |
| ...process.env, |
| NODE_ENV: undefined, |
| __NEXT_TEST_MODE: 'true', |
| FORCE_COLOR: 3, |
| ...opts.env, |
| } |
|
|
| const nodeArgs = opts.nodeArgs || [] |
| return new Promise((resolve, reject) => { |
| const instance = spawn(NEXT_BIN, [...nodeArgs, ...argv], { |
| cwd: CWD, |
| env, |
| }) |
| let didResolve = false |
|
|
| function handleStdout(data) { |
| const message = data.toString() |
| const bootupMarkers = { |
| dev: /Ready in .*/i, |
| start: /started server/i, |
| } |
| if ( |
| (opts.bootupMarker && opts.bootupMarker.test(message)) || |
| bootupMarkers[opts.nextStart ? 'start' : 'dev'].test(message) |
| ) { |
| if (!didResolve) { |
| didResolve = true |
| resolve(instance) |
| instance.removeListener('data', handleStdout) |
| } |
| } |
|
|
| if (typeof opts.onStdout === 'function') { |
| opts.onStdout(message) |
| } |
|
|
| if (opts.stdout !== false) { |
| process.stdout.write(message) |
| } |
| } |
|
|
| function handleStderr(data) { |
| const message = data.toString() |
| if (typeof opts.onStderr === 'function') { |
| opts.onStderr(message) |
| } |
|
|
| if (opts.stderr !== false) { |
| process.stderr.write(message) |
| } |
| } |
|
|
| instance.stdout.on('data', handleStdout) |
| instance.stderr.on('data', handleStderr) |
|
|
| instance.on('close', () => { |
| instance.stdout.removeListener('data', handleStdout) |
| instance.stderr.removeListener('data', handleStderr) |
| if (!didResolve) { |
| didResolve = true |
| resolve() |
| } |
| }) |
|
|
| instance.on('error', (err) => { |
| reject(err) |
| }) |
| }) |
| } |
|
|
| function waitFor(millis) { |
| return new Promise((resolve) => setTimeout(resolve, millis)) |
| } |
|
|
| for (const testCase of [ |
| 'client-components-only', |
| 'server-and-client-components', |
| 'server-components-only', |
| ]) { |
| await fs.rm('.next', { recursive: true }).catch(() => {}) |
| const file = new File(join(CWD, `app/${testCase}/page.js`)) |
| const results = [] |
|
|
| try { |
| if (command === 'dev' || command === 'all') { |
| const instance = await runNextCommandDev(['dev', '--port', '3000']) |
|
|
| function waitForCompiled() { |
| return new Promise((resolve) => { |
| function waitForOnData(data) { |
| const message = data.toString() |
| const compiledRegex = |
| /Compiled (?:.+ )?in (\d*[.]?\d+)\s*(m?s)(?: \((\d+) modules\))?/gm |
| const matched = compiledRegex.exec(message) |
| if (matched) { |
| resolve({ |
| 'time (ms)': |
| (matched[2] === 's' ? 1000 : 1) * Number(matched[1]), |
| modules: Number(matched[3]), |
| }) |
| instance.stdout.removeListener('data', waitForOnData) |
| } |
| } |
| instance.stdout.on('data', waitForOnData) |
| }) |
| } |
|
|
| const [res, initial] = await Promise.all([ |
| fetch(`http://localhost:3000/${testCase}`), |
| waitForCompiled(), |
| ]) |
| if (res.status !== 200) { |
| throw new Error(`Fetching /${testCase} failed`) |
| } |
|
|
| results.push(initial) |
|
|
| await waitFor(1000) |
|
|
| file.replace('Hello', 'Hello!') |
|
|
| results.push(await waitForCompiled()) |
|
|
| await waitFor(1000) |
|
|
| file.replace('Hello', 'Hello!') |
|
|
| results.push(await waitForCompiled()) |
|
|
| await waitFor(1000) |
|
|
| file.replace('Hello', 'Hello!') |
|
|
| results.push(await waitForCompiled()) |
|
|
| console.table(results) |
|
|
| await killApp(instance) |
| } |
| if (command === 'build' || command === 'all') { |
| |
| await fs.rm('.next', { recursive: true, force: true }).catch(() => {}) |
|
|
| execSync(`node ${NEXT_BIN} build ./bench/nested-deps-app-router`, { |
| cwd: ROOT_DIR, |
| stdio: 'inherit', |
| env: { |
| ...process.env, |
| TRACE_TARGET: 'jaeger', |
| }, |
| }) |
| const traceString = await fs.readFile(join(CWD, '.next', 'trace'), 'utf8') |
| const traces = traceString |
| .split('\n') |
| .filter((line) => line) |
| .map((line) => JSON.parse(line)) |
| const { duration } = traces |
| .pop() |
| .find(({ name }) => name === 'next-build') |
| console.info('next build duration: ', prettyMs(duration / 1000)) |
| } |
| } finally { |
| file.restore() |
| } |
| } |
|
|
