04b13f52a5
Seems we aren't ignoring the already published error correctly. x-ref: https://github.com/vercel/next.js/actions/runs/8118349923/job/22192598805 Closes NEXT-2668
184 lines
4.8 KiB
JavaScript
Executable file
184 lines
4.8 KiB
JavaScript
Executable file
#!/usr/bin/env node
|
|
// @ts-check
|
|
|
|
const path = require('path')
|
|
const execa = require('execa')
|
|
const { Sema } = require('async-sema')
|
|
const { execSync } = require('child_process')
|
|
const fs = require('fs')
|
|
|
|
const cwd = process.cwd()
|
|
|
|
;(async function () {
|
|
let isCanary = true
|
|
|
|
try {
|
|
const tagOutput = execSync(
|
|
`node ${path.join(__dirname, 'check-is-release.js')}`
|
|
).toString()
|
|
console.log(tagOutput)
|
|
|
|
if (tagOutput.trim().startsWith('v')) {
|
|
isCanary = tagOutput.includes('-canary')
|
|
}
|
|
} catch (err) {
|
|
console.log(err)
|
|
|
|
if (err.message && err.message.includes('no tag exactly matches')) {
|
|
console.log('Nothing to publish, exiting...')
|
|
return
|
|
}
|
|
throw err
|
|
}
|
|
console.log(`Publishing ${isCanary ? 'canary' : 'stable'}`)
|
|
|
|
if (!process.env.NPM_TOKEN) {
|
|
console.log('No NPM_TOKEN, exiting...')
|
|
return
|
|
}
|
|
|
|
const packagesDir = path.join(cwd, 'packages')
|
|
const packageDirs = fs.readdirSync(packagesDir)
|
|
const publishSema = new Sema(2)
|
|
|
|
const publish = async (pkg, retry = 0) => {
|
|
let output = ''
|
|
try {
|
|
await publishSema.acquire()
|
|
const child = execa(
|
|
`npm`,
|
|
[
|
|
'publish',
|
|
`${path.join(packagesDir, pkg)}`,
|
|
'--access',
|
|
'public',
|
|
'--ignore-scripts',
|
|
...(isCanary ? ['--tag', 'canary'] : []),
|
|
],
|
|
{ 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 ${pkg}`, err)
|
|
|
|
if (
|
|
output.includes('cannot publish over the previously published versions')
|
|
) {
|
|
console.error('Ignoring already published error', pkg)
|
|
return
|
|
}
|
|
|
|
if (retry >= 3) {
|
|
throw err
|
|
}
|
|
} finally {
|
|
publishSema.release()
|
|
}
|
|
// Recursive call need to be outside of the publishSema
|
|
const retryDelaySeconds = 15
|
|
console.log(`retrying in ${retryDelaySeconds}s`)
|
|
await new Promise((resolve) =>
|
|
setTimeout(resolve, retryDelaySeconds * 1000)
|
|
)
|
|
await publish(pkg, retry + 1)
|
|
}
|
|
|
|
const undraft = async () => {
|
|
const githubToken = process.env.RELEASE_BOT_GITHUB_TOKEN
|
|
|
|
if (!githubToken) {
|
|
throw new Error(`Missing RELEASE_BOT_GITHUB_TOKEN`)
|
|
}
|
|
|
|
if (isCanary) {
|
|
try {
|
|
const ghHeaders = {
|
|
Accept: 'application/vnd.github+json',
|
|
Authorization: `Bearer ${githubToken}`,
|
|
'X-GitHub-Api-Version': '2022-11-28',
|
|
}
|
|
const { version: _version } = require('../lerna.json')
|
|
const version = `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 === version
|
|
)
|
|
} 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: version,
|
|
}),
|
|
})
|
|
|
|
if (undraftRes.ok) {
|
|
console.log('un-drafted canary release successfully')
|
|
} else {
|
|
console.log(`Failed to undraft`, await undraftRes.text())
|
|
}
|
|
} catch (err) {
|
|
console.error(`Failed to undraft release`, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
const results = await Promise.allSettled(
|
|
packageDirs.map(async (packageDir) => {
|
|
const pkgJson = JSON.parse(
|
|
await fs.promises.readFile(
|
|
path.join(packagesDir, packageDir, 'package.json'),
|
|
'utf-8'
|
|
)
|
|
)
|
|
|
|
if (pkgJson.private) {
|
|
console.log(`Skipping private package ${packageDir}`)
|
|
return
|
|
}
|
|
await publish(packageDir)
|
|
})
|
|
)
|
|
|
|
if (results.some((item) => item.status === 'rejected')) {
|
|
console.error(`Not all packages published successfully`, results)
|
|
process.exit(1)
|
|
}
|
|
await undraft()
|
|
})()
|