vercel__next.js/scripts/publish-release.js

#!/usr/bin/env node
// @ts-check

const path = require('path')
const execa = require('execa')
const semver = require('semver')
const { Sema } = require('async-sema')
const fs = require('fs/promises')
const {
  getGitHubToken,
  getGitHubTokenMissingMessage,
} = require('./release-github-auth')

const cwd = process.cwd()
const dryRun = process.argv.includes('--dry-run')
const maxPublishAttempts = 4
const publishRetryDelaySeconds = 15

;(async function () {
  if (dryRun) {
    console.log('Dry run: not publishing to npm')
  }
  const publishSema = new Sema(2)

  const { version } = JSON.parse(
    await fs.readFile(path.join(cwd, 'lerna.json'), 'utf-8')
  )
  const parsedVersion = semver.parse(version)
  if (parsedVersion === null) {
    throw new Error(`Invalid version in lerna.json: ${version}`)
  }
  const prereleaseChannel = parsedVersion.prerelease[0]
  const isPrerelease = prereleaseChannel != null
  console.log(`Publishing ${version}`)

  let npmDistTag = isPrerelease ? String(prereleaseChannel) : 'latest'

  try {
    if (!isPrerelease) {
      const res = await fetch(
        `https://registry.npmjs.org/-/package/next/dist-tags`
      )
      const tags = await res.json()

      if (semver.lt(version, tags.latest)) {
        // If the current version is less than the latest, it means this
        // is a backport release. Since NPM sets the 'latest' tag by default
        // during publishing, when users install `next@latest`, they might
        // get the backported version instead of the actual "latest" version.
        // Therefore, we explicitly set the tag as 'backport' for backports.
        // But force @latest tag if we accidentally tagged a prerelase as latest
        if (!semver.prerelease(tags.latest)) {
          npmDistTag = 'backport'
        }
      }
    }
  } catch (error) {
    console.log('Failed to fetch Next.js dist tags from the NPM registry.')
    throw error
  }

  console.log(`Publishing as "${npmDistTag}" dist tag...`)

  const publish = async (label, args, attempt = 1) => {
    let output = ''
    try {
      await publishSema.acquire()
      const child = execa('pnpm', args, { stdio: 'pipe' })
      const handleData = (type) => (chunk) => {
        process[type].write(chunk)
        output += chunk.toString()
      }
      child.stdout?.on('data', handleData('stdout'))
      child.stderr?.on('data', handleData('stderr'))
      // Return here to avoid retry logic
      return await child
    } catch (err) {
      console.error(
        `Failed to publish ${label} (attempt ${attempt} of ${maxPublishAttempts})`,
        err
      )

      if (
        output.includes('cannot publish over the previously published versions')
      ) {
        console.error('Ignoring already published error', label)
        return
      }

      if (attempt >= maxPublishAttempts) {
        throw err
      }
    } finally {
      publishSema.release()
    }
    // Recursive call need to be outside of the publishSema
    console.log(`retrying ${label} in ${publishRetryDelaySeconds}s`)
    await new Promise((resolve) =>
      setTimeout(resolve, publishRetryDelaySeconds * 1000)
    )
    await publish(label, args, attempt + 1)
  }

  // Copy binaries to package folders, update version, and publish
  const nativePackagesDir = path.join(cwd, 'crates/next-napi-bindings/npm')
  const platforms = (await fs.readdir(nativePackagesDir)).filter(
    (name) => !name.startsWith('.')
  )

  const nativeResults = await Promise.allSettled(
    platforms.map(async (platform) => {
      const binaryName = `next-swc.${platform}.node`
      try {
        await fs.cp(
          path.join(cwd, 'packages/next-swc/native', binaryName),
          path.join(nativePackagesDir, platform, binaryName)
        )
      } catch (error) {
        if (dryRun) {
          console.warn(
            `Binary ${binaryName} not found, but ignoring due to dry run`
          )
          return
        }
        throw error
      }

      const pkgDir = path.join(nativePackagesDir, platform)
      const pkg = JSON.parse(
        await fs.readFile(path.join(pkgDir, 'package.json'), {
          encoding: 'utf-8',
        })
      )
      pkg.version = version
      await fs.writeFile(
        path.join(pkgDir, 'package.json'),
        JSON.stringify(pkg, null, 2)
      )
      await publish(platform, [
        'publish',
        pkgDir,
        '--access',
        'public',
        '--no-git-checks',
        '--ignore-scripts',
        '--tag',
        npmDistTag,
        ...(dryRun ? ['--dry-run'] : []),
      ])
    })
  )

  // Update name/version of wasm packages and publish
  const pkgDirectory = 'crates/wasm'
  const wasmDir = path.join(cwd, pkgDirectory)
  const wasmResults = await Promise.allSettled(
    ['web', 'nodejs'].map(async (wasmTarget) => {
      const pkgDir = path.join(wasmDir, `pkg-${wasmTarget}`)
      const wasmPkg = JSON.parse(
        await fs.readFile(path.join(pkgDir, 'package.json'), {
          encoding: 'utf-8',
        })
      )
      wasmPkg.name = `@next/swc-wasm-${wasmTarget}`
      wasmPkg.version = version
      wasmPkg.repository = {
        type: 'git',
        url: 'https://github.com/vercel/next.js',
        directory: pkgDirectory,
      }
      await fs.writeFile(
        path.join(pkgDir, 'package.json'),
        JSON.stringify(wasmPkg, null, 2)
      )
      await publish(`wasm-${wasmTarget}`, [
        'publish',
        pkgDir,
        '--access',
        'public',
        '--no-git-checks',
        '--ignore-scripts',
        '--tag',
        npmDistTag,
        ...(dryRun ? ['--dry-run'] : []),
      ])
    })
  )

  if (nativeResults.some((item) => item.status === 'rejected')) {
    console.error(
      `Not all native packages published successfully`,
      nativeResults
    )
    process.exit(1)
  }

  if (wasmResults.some((item) => item.status === 'rejected')) {
    console.error(`Not all wasm packages published successfully`, wasmResults)
    if (process.env.BAIL_ON_NATIVE_WASM_PUBLISH_FAILURE === 'true') {
      process.exit(1)
    } else {
      console.warn(
        'Continuing with release even though some wasm packages failed to publish because BAIL_ON_NATIVE_WASM_PUBLISH_FAILURE is not set to true'
      )
    }
  }

  // Update optional dependencies versions
  const nextPkg = JSON.parse(
    await fs.readFile(path.join(cwd, 'packages/next/package.json'), {
      encoding: 'utf-8',
    })
  )
  for (const platform of platforms) {
    const optionalDependencies = nextPkg.optionalDependencies || {}
    optionalDependencies['@next/swc-' + platform] = version
    nextPkg.optionalDependencies = optionalDependencies
  }
  // These props are only needed for development and build so we strip
  // before publishing to reduce the total metadata size. The max is
  // 100 MB for all versions of a pkg and we are currently at 30MB. Run:
  // curl -w '%{size_download}' -so /dev/null https://registry.npmjs.org/next | awk '{print $1/1000000 " MB"}'
  for (const field of ['devDependencies', 'taskr', 'scripts']) {
    delete nextPkg[field]
  }
  await fs.writeFile(
    path.join(cwd, 'packages/next/package.json'),
    JSON.stringify(nextPkg, null, 2)
  )

  if (isPrerelease) {
    // Lerna does not update peerDependencies at version time, and a static
    // range like "^16.0.0" never satisfies a fresh prerelease version.
    // Append the release version to any peer dependency on packages published
    // from this repo so the published prerelease accepts its own version while
    // keeping the stable ranges.
    // Stable releases keep their wide ranges untouched so a published package
    // keeps working with newer Next.js minors.
    // TODO: Use `|| workspace:*` once pnpm supports that. Only a lone `workspace:*`
    // works at the moment
    const pnpmListJson = await execa('pnpm', [
      '--silent',
      '--recursive',
      '--filter',
      './packages/**',
      'list',
      '--depth',
      '-1',
      '--json',
    ])
    const workspacePackages = JSON.parse(pnpmListJson.stdout)
    const publishedPackageNames = new Set(
      workspacePackages
        .filter((workspacePackage) => !workspacePackage.private)
        .map((workspacePackage) => workspacePackage.name)
    )

    for (const workspacePackage of workspacePackages) {
      if (workspacePackage.private) {
        continue
      }

      const packageJsonPath = path.join(workspacePackage.path, 'package.json')
      const manifest = JSON.parse(await fs.readFile(packageJsonPath, 'utf-8'))
      const peerDependencies = manifest.peerDependencies ?? {}
      let updated = false

      for (const dependencyName of Object.keys(peerDependencies)) {
        if (publishedPackageNames.has(dependencyName)) {
          peerDependencies[dependencyName] =
            `${peerDependencies[dependencyName]} || ${version}`
          updated = true
        }
      }

      if (updated) {
        await fs.writeFile(packageJsonPath, JSON.stringify(manifest, null, 2))
        console.log(
          `Appended ${version} to peer dependencies in ${workspacePackage.name}`
        )
      }
    }
  }

  await publish('workspace', [
    '--filter',
    './packages/**',
    'publish',
    '--recursive',
    '--access',
    'public',
    '--no-git-checks',
    '--ignore-scripts',
    '--report-summary',
    '--tag',
    npmDistTag,
    ...(dryRun ? ['--dry-run'] : []),
  ])

  if (dryRun) {
    console.log('Dry run: skipping GitHub release un-draft')
    return
  }

  const githubToken = getGitHubToken()

  if (!githubToken) {
    throw new Error(getGitHubTokenMissingMessage())
  }

  if (isPrerelease) {
    try {
      const ghHeaders = {
        Accept: 'application/vnd.github+json',
        Authorization: `Bearer ${githubToken}`,
        'X-GitHub-Api-Version': '2022-11-28',
      }
      const tag = `v${version}`

      let release
      let releasesData

      // The release might take a minute to show up in
      // the list so retry a bit
      for (let i = 0; i < 6; i++) {
        try {
          const releaseUrlRes = await fetch(
            `https://api.github.com/repos/vercel/next.js/releases`,
            {
              headers: ghHeaders,
            }
          )
          releasesData = await releaseUrlRes.json()

          release = releasesData.find((release) => release.tag_name === tag)
        } catch (err) {
          console.log(`Fetching release failed`, err)
        }
        if (!release) {
          console.log(`Retrying in 10s...`)
          await new Promise((resolve) => setTimeout(resolve, 10 * 1000))
        }
      }

      if (!release) {
        console.log(`Failed to find release`, releasesData)
        return
      }

      const undraftRes = await fetch(release.url, {
        headers: ghHeaders,
        method: 'PATCH',
        body: JSON.stringify({
          draft: false,
          name: tag,
        }),
      })

      if (undraftRes.ok) {
        console.log(`un-drafted ${prereleaseChannel} release successfully`)
      } else {
        console.log(`Failed to undraft`, await undraftRes.text())
      }
    } catch (err) {
      console.error(`Failed to undraft release`, err)
    }
  }
})().catch((err) => {
  console.error(err)
  process.exit(1)
})