278 lines
8.4 KiB
TypeScript
278 lines
8.4 KiB
TypeScript
import * as fs from 'fs'
|
|
import {Octokit} from '@octokit/core'
|
|
import {Endpoints} from '@octokit/types'
|
|
import * as core from '@actions/core'
|
|
import * as github from '@actions/github'
|
|
import * as path from 'path'
|
|
import * as glob from 'glob'
|
|
import {retry} from '@lifeomic/attempt'
|
|
|
|
const getRef = 'GET /repos/{owner}/{repo}/git/ref/{ref}' as const
|
|
const releaseByTag = 'GET /repos/{owner}/{repo}/releases/tags/{tag}' as const
|
|
const createRelease = 'POST /repos/{owner}/{repo}/releases' as const
|
|
const updateRelease =
|
|
'PATCH /repos/{owner}/{repo}/releases/{release_id}' as const
|
|
const repoAssets =
|
|
'GET /repos/{owner}/{repo}/releases/{release_id}/assets' as const
|
|
const uploadAssets =
|
|
'POST {origin}/repos/{owner}/{repo}/releases/{release_id}/assets{?name,label}' as const
|
|
const deleteAssets =
|
|
'DELETE /repos/{owner}/{repo}/releases/assets/{asset_id}' as const
|
|
|
|
type ReleaseByTagResp = Endpoints[typeof releaseByTag]['response']
|
|
type CreateReleaseResp = Endpoints[typeof createRelease]['response']
|
|
type RepoAssetsResp = Endpoints[typeof repoAssets]['response']['data']
|
|
type UploadAssetResp = Endpoints[typeof uploadAssets]['response']
|
|
type UpdateReleaseResp = Endpoints[typeof updateRelease]['response']
|
|
type UpdateReleaseParams = Endpoints[typeof updateRelease]['parameters']
|
|
|
|
async function get_release_by_tag(
|
|
tag: string,
|
|
draft: boolean,
|
|
prerelease: boolean,
|
|
make_latest: boolean,
|
|
release_name: string,
|
|
body: string,
|
|
octokit: Octokit,
|
|
overwrite: boolean,
|
|
promote: boolean,
|
|
target_commit: string
|
|
): Promise<ReleaseByTagResp | CreateReleaseResp | UpdateReleaseResp> {
|
|
let release: ReleaseByTagResp
|
|
try {
|
|
core.debug(`Getting release by tag ${tag}.`)
|
|
release = await octokit.request(releaseByTag, {
|
|
...repo(),
|
|
tag: tag
|
|
})
|
|
} catch (error: any) {
|
|
// If this returns 404, we need to create the release first.
|
|
if (error.status === 404) {
|
|
core.debug(
|
|
`Release for tag ${tag} doesn't exist yet so we'll create it now.`
|
|
)
|
|
if (target_commit) {
|
|
try {
|
|
await octokit.request(getRef, {
|
|
...repo(),
|
|
ref: `tags/${tag}`
|
|
})
|
|
core.warning(
|
|
`Ignoring target_commit as the tag ${tag} already exists`
|
|
)
|
|
} catch (tagError: any) {
|
|
if (tagError.status !== 404) {
|
|
throw tagError
|
|
}
|
|
}
|
|
}
|
|
return await octokit.request(createRelease, {
|
|
...repo(),
|
|
tag_name: tag,
|
|
draft: draft,
|
|
prerelease: prerelease,
|
|
make_latest: make_latest ? 'true' : 'false',
|
|
name: release_name,
|
|
body: body,
|
|
target_commitish: target_commit
|
|
})
|
|
} else {
|
|
throw error
|
|
}
|
|
}
|
|
let updateObject: Partial<UpdateReleaseParams> | undefined
|
|
if (promote && release.data.prerelease) {
|
|
core.debug(`The ${tag} is a prerelease, promoting it to a release.`)
|
|
updateObject = updateObject || {}
|
|
updateObject.prerelease = false
|
|
}
|
|
if (overwrite) {
|
|
if (release_name && release.data.name !== release_name) {
|
|
core.debug(
|
|
`The ${tag} release already exists with a different name ${release.data.name} so we'll overwrite it.`
|
|
)
|
|
updateObject = updateObject || {}
|
|
updateObject.name = release_name
|
|
}
|
|
if (body && release.data.body !== body) {
|
|
core.debug(
|
|
`The ${tag} release already exists with a different body ${release.data.body} so we'll overwrite it.`
|
|
)
|
|
updateObject = updateObject || {}
|
|
updateObject.body = body
|
|
}
|
|
}
|
|
if (updateObject) {
|
|
return octokit.request(updateRelease, {
|
|
...repo(),
|
|
...updateObject,
|
|
release_id: release.data.id
|
|
})
|
|
}
|
|
return release
|
|
}
|
|
|
|
async function upload_to_release(
|
|
release: ReleaseByTagResp | CreateReleaseResp | UpdateReleaseResp,
|
|
file: string,
|
|
asset_name: string,
|
|
tag: string,
|
|
overwrite: boolean,
|
|
octokit: ReturnType<(typeof github)['getOctokit']>
|
|
): Promise<undefined | string> {
|
|
const stat = fs.statSync(file)
|
|
if (!stat.isFile()) {
|
|
core.debug(`Skipping ${file}, since its not a file`)
|
|
return
|
|
}
|
|
const file_size = stat.size
|
|
if (file_size === 0) {
|
|
core.debug(`Skipping ${file}, since its size is 0`)
|
|
return
|
|
}
|
|
|
|
// Check for duplicates.
|
|
const assets: RepoAssetsResp = await octokit.paginate(repoAssets, {
|
|
...repo(),
|
|
release_id: release.data.id
|
|
})
|
|
const duplicate_asset = assets.find(a => a.name === asset_name)
|
|
if (duplicate_asset !== undefined) {
|
|
if (overwrite) {
|
|
core.debug(
|
|
`An asset called ${asset_name} already exists in release ${tag} so we'll overwrite it.`
|
|
)
|
|
await octokit.request(deleteAssets, {
|
|
...repo(),
|
|
asset_id: duplicate_asset.id
|
|
})
|
|
} else {
|
|
core.setFailed(`An asset called ${asset_name} already exists.`)
|
|
return duplicate_asset.browser_download_url
|
|
}
|
|
} else {
|
|
core.debug(
|
|
`No pre-existing asset called ${asset_name} found in release ${tag}. All good.`
|
|
)
|
|
}
|
|
|
|
core.debug(`Uploading ${file} to ${asset_name} in release ${tag}.`)
|
|
const uploaded_asset: UploadAssetResp = await retry(
|
|
async () => {
|
|
return octokit.request(uploadAssets, {
|
|
...repo(),
|
|
release_id: release.data.id,
|
|
url: release.data.upload_url,
|
|
name: asset_name,
|
|
data: fs.createReadStream(file) as any,
|
|
headers: {
|
|
'content-type': 'binary/octet-stream',
|
|
'content-length': file_size
|
|
}
|
|
})
|
|
},
|
|
{
|
|
maxAttempts: 3
|
|
}
|
|
)
|
|
return uploaded_asset.data.browser_download_url
|
|
}
|
|
|
|
function repo(): {owner: string; repo: string} {
|
|
const repo_name = core.getInput('repo_name')
|
|
// If we're not targeting a foreign repository, we can just return immediately and don't have to do extra work.
|
|
if (!repo_name) {
|
|
return github.context.repo
|
|
}
|
|
const owner = repo_name.substring(0, repo_name.indexOf('/'))
|
|
if (!owner) {
|
|
throw new Error(`Could not extract 'owner' from 'repo_name': ${repo_name}.`)
|
|
}
|
|
const repo_ = repo_name.substring(repo_name.indexOf('/') + 1)
|
|
if (!repo_) {
|
|
throw new Error(`Could not extract 'repo' from 'repo_name': ${repo_name}.`)
|
|
}
|
|
return {
|
|
owner,
|
|
repo: repo_
|
|
}
|
|
}
|
|
|
|
async function run(): Promise<void> {
|
|
try {
|
|
// Get the inputs from the workflow file: https://github.com/actions/toolkit/tree/master/packages/core#inputsoutputs
|
|
const token = core.getInput('repo_token', {required: true})
|
|
const file = core.getInput('file', {required: true})
|
|
const tag = core
|
|
.getInput('tag', {required: true})
|
|
.replace('refs/tags/', '')
|
|
.replace('refs/heads/', '')
|
|
|
|
const file_glob = core.getInput('file_glob') == 'true' ? true : false
|
|
const overwrite = core.getInput('overwrite') == 'true' ? true : false
|
|
const promote = core.getInput('promote') == 'true' ? true : false
|
|
const draft = core.getInput('draft') == 'true' ? true : false
|
|
const prerelease = core.getInput('prerelease') == 'true' ? true : false
|
|
const make_latest = core.getInput('make_latest') != 'false' ? true : false
|
|
const release_name = core.getInput('release_name')
|
|
const target_commit = core.getInput('target_commit')
|
|
const body = core
|
|
.getInput('body')
|
|
.replace(/%0A/gi, '\n')
|
|
.replace(/%0D/gi, '\r')
|
|
.replace(/%25/g, '%')
|
|
|
|
const octokit = github.getOctokit(token)
|
|
const release = await get_release_by_tag(
|
|
tag,
|
|
draft,
|
|
prerelease,
|
|
make_latest,
|
|
release_name,
|
|
body,
|
|
octokit,
|
|
overwrite,
|
|
promote,
|
|
target_commit
|
|
)
|
|
|
|
if (file_glob) {
|
|
const files = glob.sync(file)
|
|
if (files.length > 0) {
|
|
for (const file_ of files) {
|
|
const asset_name = path.basename(file_)
|
|
const asset_download_url = await upload_to_release(
|
|
release,
|
|
file_,
|
|
asset_name,
|
|
tag,
|
|
overwrite,
|
|
octokit
|
|
)
|
|
core.setOutput('browser_download_url', asset_download_url)
|
|
}
|
|
} else {
|
|
core.setFailed('No files matching the glob pattern found.')
|
|
}
|
|
} else {
|
|
const asset_name =
|
|
core.getInput('asset_name') !== ''
|
|
? core.getInput('asset_name').replace(/\$tag/g, tag)
|
|
: path.basename(file)
|
|
const asset_download_url = await upload_to_release(
|
|
release,
|
|
file,
|
|
asset_name,
|
|
tag,
|
|
overwrite,
|
|
octokit
|
|
)
|
|
core.setOutput('browser_download_url', asset_download_url)
|
|
}
|
|
} catch (error: any) {
|
|
core.setFailed(error.message)
|
|
}
|
|
}
|
|
|
|
run()
|