feat: add complete release process (#2)

henrycunh · web-flow · commit c8dae1186703 · 2022-04-20T15:47:38.000-03:00
* feat: add better error messages on `tagReleaseCandidate`

* feat: add git commiter identity

* fix: correct input names and add error message to create release fn

* fix: get correct version and commit url

* fix: improve error messages

* fix: close log groups and add more logging

* fix: correct release payload

* fix: correct fields names

* feat: add release candidate option

* fix: improve error messages

* fix: improve error logs on git operations

* fix: add semver guards

* fix: debug

* fix: debug

* fix: debug

* fix: debug

* fix: remove console log

* fix: improve version checks

* fix: correct git sorting on changelog gen

* chore: update dist

* fix: correct log grouping
diff --git a/action.yml b/action.yml
@@ -5,6 +5,18 @@ inputs:
     github-token:
         required: true
         description: GitHub personal access token
+    git-committer-name:
+        required: true
+        description: Git committer name
+        default: Publish SemVer release action
+    git-committer-email:
+        required: true
+        description: Git committer email
+        default: publish-semver@github.com
+    release-candidate:
+        required: false
+        description: Determines if the release is a release candidate
+        default: 'true'
 outputs:
     next-version:
         description: Next version to be released
diff --git a/dist/index.js b/dist/index.js
diff --git a/dist/index.js.map b/dist/index.js.map
diff --git a/src/changelog.ts b/src/changelog.ts
@@ -2,6 +2,8 @@ import { getInput } from '@actions/core'
 import { getExecOutput } from '@actions/exec'
 import { getOctokit } from '@actions/github'
 import type { Context } from '@actions/github/lib/context'
+import * as core from '@actions/core'
+import { getLastGitTag } from './git'
 import type { ReleaseType } from './version'
 import { getReleaseTypeFromCommitMessage } from './version'
 
@@ -14,24 +16,32 @@ ReturnType<typeof getOctokit>['rest']['repos']['listCommits']
 
 const run = async(command: string) => (await getExecOutput(command)).stdout
 
-const getLastCommits = async(context: Context) => {
+const getLastCommits = async(context: Context, considerReleaseCandidates: boolean) => {
     const githubToken = getInput('github-token') || process.env.GH_TOKEN
     if (githubToken === '' || githubToken === undefined)
         throw new Error('GitHub token is required')
 
     const github = getOctokit(githubToken).rest
 
     // get the sha of the last tagged commit
-    const lastTag = await run('git describe --tags --abbrev=0')
+    const lastTag = await getLastGitTag(considerReleaseCandidates)
     const lastTaggedCommitSha = await run(`git rev-list -n 1 ${lastTag}`)
+    const lastTaggedCommitDate = await run(`git show -s --format=%ci ${lastTaggedCommitSha}`)
+    core.info(`Getting commits since ${lastTaggedCommitDate} [${lastTag}](${lastTaggedCommitSha})`)
 
     const { data: commits } = await github.repos.listCommits({
         owner: context.repo.owner,
         repo: context.repo.repo,
+        since: lastTaggedCommitDate,
     })
 
+    const commitsSortedByDateDesc = commits.sort((a, b) => {
+        const aDate = new Date(String(a.commit.author?.date))
+        const bDate = new Date(String(b.commit.author?.date))
+        return bDate.getTime() - aDate.getTime()
+    })
     const lastCommits = []
-    for (const commit of commits) {
+    for (const commit of commitsSortedByDateDesc) {
         if (commit.sha === lastTaggedCommitSha)
             break
         lastCommits.push(commit)
@@ -43,7 +53,8 @@ const getLastCommits = async(context: Context) => {
 const groupCommitsByReleaseType = (commits: CommitList) => {
     return commits
         .map((commit) => {
-            const { message, url, author } = commit.commit
+            const { html_url: url } = commit
+            const { message, author } = commit.commit
             const type = getReleaseTypeFromCommitMessage(message)
             return { message, type, url, author: String(author?.name) }
         })
@@ -60,8 +71,8 @@ const groupCommitsByReleaseType = (commits: CommitList) => {
 const formatCommitsByType = (commitsByType: CommitsByReleaseType) => {
     let changelog = ''
     const getCommitInfo = (commit: { message: string; url: string; author: string }) => {
-        const message = commit.message.split(':')[1].trim()
-        const scope = commit.message.match(/^(.*?): /)?.[1] ?? ''
+        const message = commit.message.split(':')[1].split('\n').shift()?.trim()
+        const scope = commit.message.match(/\(([^/)]+)\):/)?.[1] ?? ''
         const commitSha = commit.url.split('/').pop()?.slice(0, 8)
         return { message, scope, commitSha }
     }
@@ -73,30 +84,34 @@ const formatCommitsByType = (commitsByType: CommitsByReleaseType) => {
     }
     if (commitsByType.minor) {
         if (!commitsByType.major)
-            changelog += '### Features\n'
+            changelog += '\n### Features\n'
 
         const featureCommits = [
             ...(commitsByType.major || []),
             ...(commitsByType.minor || []),
         ]
         for (const commit of featureCommits) {
             const { message, scope, commitSha } = getCommitInfo(commit)
-            changelog += `- **(${scope})** ${message} ([${commitSha}](${commit.url}))\n`
+            changelog += `- ${scope ? `**(${scope})**` : ''} ${message} ([${commitSha}](${commit.url}))\n`
         }
     }
     if (commitsByType.patch) {
-        changelog += '### Bug Fixes\n'
+        changelog += '\n### Bug Fixes\n'
         for (const commit of commitsByType.patch) {
             const { message, scope, commitSha } = getCommitInfo(commit)
-            changelog += `- **(${scope})** ${message} ([${commitSha}](${commit.url}))\n`
+            changelog += `- ${scope ? `**(${scope})**` : ''} ${message} ([${commitSha}](${commit.url}))\n`
         }
     }
 
     return changelog
 }
 
-export const generateChangelog = async(context: Context) => {
-    const lastCommits = await getLastCommits(context)
+export const generateChangelog = async(context: Context, considerReleaseCandidates: boolean) => {
+    core.startGroup('Generating changelog')
+    const lastCommits = await getLastCommits(context, considerReleaseCandidates)
     const commitsByType = groupCommitsByReleaseType(lastCommits)
-    return formatCommitsByType(commitsByType)
+    const formattedChangelog = formatCommitsByType(commitsByType)
+    core.info(formattedChangelog)
+    core.endGroup()
+    return formattedChangelog
 }
diff --git a/src/git.ts b/src/git.ts
@@ -1,17 +1,40 @@
 import { getExecOutput } from '@actions/exec'
 import * as core from '@actions/core'
 
-export const getLastGitTag = async(): Promise<string | null> => {
+export const getLastGitTag = async(considerReleaseCandidates: boolean, logInGroup = false): Promise<string | null> => {
     try {
-        core.startGroup('Getting last git tag')
-        const { stdout: lastGitTag, exitCode } = await getExecOutput(
-            'git describe --tags --abbrev=0',
-            [],
-            { silent: true },
+        if (logInGroup)
+            core.startGroup('Getting last git tag')
+        const { stdout: gitTagList, exitCode } = await getExecOutput(
+            'git for-each-ref --sort=creatordate --format "%(refname)" refs/tags',
         )
         if (exitCode !== 0)
             throw Error
-        core.endGroup()
+        const filteredTags = gitTagList
+            .trim()
+            .split('\n')
+            .filter(ref =>
+                // Ensure that the line isn't empty, then check against
+                // the release candidate option input
+                Boolean(ref)
+                && ref.split('/').at(-1)?.match(/^v?\d+\.\d+\.\d+(-[\w\d]+)?$/) !== null
+                && considerReleaseCandidates
+                    ? true
+                    : !ref.includes('-rc'),
+            )
+            .reverse()
+        const lastGitTag = filteredTags
+            .at(0)
+            ?.split('/')
+            .at(-1)
+
+        if (lastGitTag === undefined || lastGitTag === '') {
+            core.info('No git tag found.')
+            throw Error
+        }
+        core.info(`Last git tag: ${lastGitTag}`)
+        if (logInGroup)
+            core.endGroup()
         return lastGitTag
     }
     catch (e) {
@@ -25,12 +48,10 @@ export const getLastCommitMessage = async(): Promise<string | null> => {
         core.startGroup('Getting last commit message')
         const { stdout: lastCommitMessage, exitCode } = await getExecOutput(
             'git log -1 --pretty=%B --no-merges',
-            [],
-            { silent: true },
         )
         if (exitCode !== 0)
             throw Error
-
+        core.endGroup()
         return lastCommitMessage
     }
     catch (e) {
@@ -39,28 +60,81 @@ export const getLastCommitMessage = async(): Promise<string | null> => {
     }
 }
 
-export const tagReleaseCandidate = async(nextVersion: string): Promise<void | null> => {
+const setGitCommiter = async(): Promise<void> => {
     try {
-        core.startGroup('Tagging release candidate')
-        const { exitCode: tagExitCode } = await getExecOutput(
-            `git tag -a ${nextVersion}-rc -m "Release candidate for ${nextVersion}"`,
+        const name = core.getInput('git-committer-name')
+        const email = core.getInput('git-committer-email')
+        if (name === '' || email === '')
+            throw new Error('Git committer name and email are required')
+
+        core.startGroup('Setting git commiter identity')
+        const { exitCode: exitCodeName } = await getExecOutput(
+            `git config --global user.name "${name}"`,
+            [],
+            { silent: true },
+        )
+        if (exitCodeName !== 0)
+            throw new Error('Could not set git commiter name')
+
+        const { exitCode: exitCodeEmail } = await getExecOutput(
+            `git config --global user.email "${email}"`,
             [],
             { silent: true },
         )
+        if (exitCodeEmail !== 0)
+            throw new Error('Could not set git commiter email')
+        core.info('Git commiter identity set.')
+        core.endGroup()
+    }
+    catch (e: any) {
+        core.error(`Could not set git commiter identity\n${e.message}`)
+    }
+}
+
+export const tagCommit = async(nextVersion: string, isReleaseCandidate: boolean): Promise<void | null> => {
+    try {
+        await setGitCommiter()
+        core.startGroup(`Tagging ${isReleaseCandidate ? 'release candidate' : 'version'} ${nextVersion}`)
+        const version = `${nextVersion}${isReleaseCandidate ? '-rc' : ''}`
+        const { exitCode: tagExitCode } = await getExecOutput(
+            `git tag -a ${version} -m "Release ${nextVersion}"`,
+        )
         if (tagExitCode !== 0)
             throw Error
 
         const { exitCode: pushExitCode } = await getExecOutput(
             'git push --tags',
-            [],
-            { silent: true },
         )
         if (pushExitCode !== 0)
             throw Error
+        core.info(`Git tag ${version} pushed.`)
+        core.endGroup()
+    }
+    catch (e) {
+        core.error('Could not tag commit')
+        return null
+    }
+}
+
+export const deleteTag = async(tag: string): Promise<void | null> => {
+    try {
+        core.startGroup('Deleting tag')
+        const { exitCode: deleteTagExitCode } = await getExecOutput(
+            `git tag -d ${tag}`,
+        )
+        if (deleteTagExitCode !== 0)
+            throw Error
 
+        const { exitCode: pushExitCode } = await getExecOutput(
+            `git push --delete origin ${tag}`,
+        )
+        if (pushExitCode !== 0)
+            throw Error
+        core.info(`Git tag ${tag} deleted.`)
         core.endGroup()
     }
     catch (e) {
+        core.error('Could not delete tag')
         return null
     }
 }
diff --git a/src/github.ts b/src/github.ts
@@ -1,28 +1,46 @@
 import { getInput } from '@actions/core'
 import { getOctokit } from '@actions/github'
+import * as core from '@actions/core'
 import type { Context } from '@actions/github/lib/context'
+import { deleteTag } from './git'
 
-export const createGithubRelease = async(context: Context, nextVersion: string, body: string) => {
+export const createGithubRelease = async(
+    context: Context,
+    nextVersion: string,
+    body: string,
+    isReleaseCandidate: boolean,
+) => {
+    core.startGroup('Creating GitHub release')
     const githubToken = getInput('github-token') || process.env.GH_TOKEN
     if (githubToken === '' || githubToken === undefined)
         throw new Error('GitHub token is required')
 
     const client = getOctokit(githubToken).rest
+    const version = isReleaseCandidate ? `${nextVersion}-rc` : nextVersion
 
-    const {
-        data: {
-            url: releaseUrl,
-        },
-    } = await client.repos.createRelease(
-        {
-            repo: context.repo.owner,
-            owner: context.repo.repo,
-            tag_name: nextVersion,
-            name: nextVersion,
-            body,
-            prerelease: true,
-        },
-    )
-
-    return releaseUrl
+    try {
+        const {
+            data: {
+                html_url: releaseUrl,
+            },
+        } = await client.repos.createRelease(
+            {
+                repo: context.repo.repo,
+                owner: context.repo.owner,
+                tag_name: version,
+                name: version,
+                body,
+                prerelease: isReleaseCandidate,
+            },
+        )
+        core.info(`Created release at ${releaseUrl}`)
+        core.endGroup()
+        return releaseUrl
+    }
+    catch (e: any) {
+        core.info('Could not create GitHub release')
+        core.endGroup()
+        await deleteTag(`${nextVersion}`)
+        core.error(`${e.status} - ${e.message}`)
+    }
 }
diff --git a/src/main.ts b/src/main.ts
@@ -1,13 +1,15 @@
 import * as core from '@actions/core'
 import { context } from '@actions/github'
 import { generateChangelog } from './changelog'
-import { getLastCommitMessage, getLastGitTag, tagReleaseCandidate } from './git'
+import { getLastCommitMessage, getLastGitTag, tagCommit } from './git'
 import { createGithubRelease } from './github'
 import { getNextVersion, getReleaseTypeFromCommitMessage } from './version'
 
 async function run(): Promise<void> {
+    const isReleaseCandidate = core.getInput('release-candidate') === 'true'
+
     try {
-        const lastVersion = await getLastGitTag()
+        const lastVersion = await getLastGitTag(isReleaseCandidate, true)
         if (lastVersion === null)
             return
 
@@ -22,13 +24,12 @@ async function run(): Promise<void> {
             const nextVersion = getNextVersion(lastVersion, releaseType)
             core.info(`Publishing a release candidate for version ${nextVersion}`)
 
-            const changelog = await generateChangelog(context)
-            core.info(changelog)
+            const changelog = await generateChangelog(context, isReleaseCandidate)
 
             // Tag commit with the next version release candidate
-            await tagReleaseCandidate(nextVersion)
+            await tagCommit(nextVersion, isReleaseCandidate)
 
-            await createGithubRelease(context, `${nextVersion}-rc`, changelog)
+            await createGithubRelease(context, nextVersion, changelog, isReleaseCandidate)
 
             core.setOutput('next-version', nextVersion)
             core.setOutput('release-type', releaseType)
diff --git a/src/version.ts b/src/version.ts
@@ -1,3 +1,4 @@
+import * as core from '@actions/core'
 export type ReleaseType = 'patch' | 'minor' | 'major'
 
 export const getReleaseTypeFromCommitMessage = (commitMessage: string): ReleaseType | null => {
@@ -11,7 +12,14 @@ export const getReleaseTypeFromCommitMessage = (commitMessage: string): ReleaseT
 }
 
 export const getNextVersion = (currentVersion: string, releaseType: ReleaseType): string => {
-    const [major, minor, patch] = currentVersion.split('.').map(Number)
+    // verify that the current version is valid semver
+    if (currentVersion.match(/^\d+\.\d+\.\d+(-[\w\d]+)?$/) === null) {
+        core.error(`Invalid current version: ${currentVersion}`)
+        throw Error
+    }
+
+    const pureVersion = currentVersion.split('-')[0]
+    const [major, minor, patch] = pureVersion.split('.').map(Number)
     return ({
         major: () => `${major + 1}.0.0`,
         minor: () => `${major}.${minor + 1}.0`,
