Merge pull request #24 from technote-space/release/v1.0.4

Release/v1.0.4

Author: technote-space

README.md

@@ -6,7 +6,11 @@
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://github.com/technote-space/release-github-actions/blob/master/LICENSE)
 
 GitHub actions to auto release.  
-Once you publish the release, this action will run build and create branch automatically.
+Once you publish the release, this action will automatically
+1. Run build
+1. Create branch for release
+1. Change tag to release branch
+1. Change release tag
 
 ## Installation
 .github/workflows/release.yml
@@ -19,7 +23,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Release GitHub Actions
-        uses: technote-space/release-github-actions@v1.0.3
+        uses: technote-space/release-github-actions@v1
         with:
           ACCESS_TOKEN: ${{ secrets.ACCESS_TOKEN }}
 ```

__tests__/utils/misc.test.ts

@@ -6,13 +6,14 @@ import {
     getCommitMessage,
     getCommitName,
     getCommitEmail,
+    getBranchName,
     getWorkspace,
     getBuildCommands,
     getGitUrl,
     detectBuildCommand,
     getRepository,
 } from '../../src/utils/misc';
-import {DEFAULT_COMMIT_MESSAGE, DEFAULT_COMMIT_NAME, DEFAULT_COMMIT_EMAIL} from '../../src/constant';
+import {DEFAULT_COMMIT_MESSAGE, DEFAULT_COMMIT_NAME, DEFAULT_COMMIT_EMAIL, DEFAULT_BRANCH_NAME} from '../../src/constant';
 
 const testEnv = () => {
     const OLD_ENV = process.env;
@@ -115,7 +116,7 @@ describe('getCommitMessage', () => {
         expect(getCommitMessage()).toBe('test');
     });
 
-    it('should get commit default message', () => {
+    it('should get default commit message', () => {
         expect(getCommitMessage()).toBe(DEFAULT_COMMIT_MESSAGE);
     });
 });
@@ -128,7 +129,7 @@ describe('getCommitName', () => {
         expect(getCommitName()).toBe('test');
     });
 
-    it('should get commit default name', () => {
+    it('should get default commit name', () => {
         expect(getCommitName()).toBe(DEFAULT_COMMIT_NAME);
     });
 });
@@ -141,11 +142,24 @@ describe('getCommitEmail', () => {
         expect(getCommitEmail()).toBe('test');
     });
 
-    it('should get commit default email', () => {
+    it('should get default commit email', () => {
         expect(getCommitEmail()).toBe(DEFAULT_COMMIT_EMAIL);
     });
 });
 
+describe('getBranchName', () => {
+    testEnv();
+
+    it('should get branch name', () => {
+        process.env.INPUT_BRANCH_NAME = 'test';
+        expect(getBranchName()).toBe('test');
+    });
+
+    it('should get default branch name', () => {
+        expect(getBranchName()).toBe(DEFAULT_BRANCH_NAME);
+    });
+});
+
 describe('getWorkspace', () => {
     testEnv();
 

action.yml

@@ -17,6 +17,9 @@ inputs:
   COMMIT_EMAIL:
     description: Git commit email.
     default: '[email protected]'
+  BRANCH_NAME:
+    description: Branch name.
+    default: 'gh-actions'
 runs:
   using: node12
   main: lib/main.js

src/constant.ts

@@ -1,6 +1,7 @@
 export const DEFAULT_COMMIT_MESSAGE = 'feat: Build for release';
 export const DEFAULT_COMMIT_NAME = 'GitHub Actions';
 export const DEFAULT_COMMIT_EMAIL = '[email protected]';
+export const DEFAULT_BRANCH_NAME = 'gh-actions';
 export const TARGET_EVENT_NAME = 'release';
 export const TARGET_EVENT_ACTION = 'published';
 export const SEARCH_BUILD_COMMAND_TARGETS = [

src/main.ts

@@ -1,5 +1,5 @@
-import {setFailed} from '@actions/core' ;
-import {context} from '@actions/github' ;
+import {setFailed} from '@actions/core';
+import {context, GitHub} from '@actions/github';
 import signale from 'signale';
 import {deploy} from './utils/command';
 import {isTargetEvent} from './utils/misc';
@@ -13,8 +13,13 @@ async function run() {
             return;
         }
 
+        if (typeof process.env.GITHUB_TOKEN === 'undefined' || process.env.GITHUB_TOKEN === '') {
+            // noinspection ExceptionCaughtLocallyJS
+            throw new Error(`Input required and not supplied: GITHUB_TOKEN`);
+        }
+
         signale.info(`Tag name: ${context.payload.release.tag_name}`);
-        await deploy(context.payload.release.tag_name, context);
+        await deploy(context.payload.release.tag_name, new GitHub(process.env.GITHUB_TOKEN), context);
     } catch (error) {
         setFailed(error.message);
     }

src/utils/command.ts

@@ -2,22 +2,25 @@ import fs from 'fs';
 import path from 'path';
 import signale from 'signale';
 import {exec} from 'child_process';
+import {GitHub} from '@actions/github/lib/github';
 import {Context} from '@actions/github/lib/context';
-import {getGitUrl, getRepository, getBuildCommands, getWorkspace, getCommitMessage, getCommitName, getCommitEmail, detectBuildCommand} from './misc';
+import {getGitUrl, getRepository, getBuildCommands, getWorkspace, getCommitMessage, getCommitName, getCommitEmail, getBranchName} from './misc';
 
-export const deploy = async (branch: string, context: Context) => {
+export const deploy = async (tagName: string, octokit: GitHub, context: Context) => {
     const workDir = path.resolve(getWorkspace(), '.work');
     const buildDir = path.resolve(workDir, 'build');
     const pushDir = path.resolve(workDir, 'push');
-    signale.info(`Deploying branch %s to %s`, branch, getRepository(context));
+    const branchName = getBranchName();
+    signale.info('Deploying branch %s to %s', branchName, getRepository(context));
 
     fs.mkdirSync(pushDir, {recursive: true});
-    if (!await cloneForBranch(pushDir, branch, context)) return;
+    if (!await cloneForBranch(pushDir, branchName, context)) return;
     if (!await prepareFiles(buildDir, pushDir, context)) return;
     if (!await copyFiles(buildDir, pushDir)) return;
     if (!await config(pushDir)) return;
     if (!await commit(pushDir)) return;
-    await push(pushDir, branch, context);
+    if (!await push(pushDir, tagName, branchName, context)) return;
+    await updateRelease(tagName, octokit, context);
 };
 
 export const prepareFiles = async (buildDir: string, pushDir: string, context: Context): Promise<boolean> => {
@@ -29,26 +32,26 @@ export const prepareFiles = async (buildDir: string, pushDir: string, context: C
     return true;
 };
 
-const cloneForBranch = async (pushDir: string, branch: string, context: Context): Promise<boolean> => {
-    signale.info(`Cloning the branch %s from the remote repo`, branch);
+const cloneForBranch = async (pushDir: string, branchName: string, context: Context): Promise<boolean> => {
+    signale.info('Cloning the branch %s from the remote repo', branchName);
 
     const url = getGitUrl(context);
-    await execAsync(`git -C ${pushDir} clone --quiet --branch=${branch} --depth=1 ${url} .`, true, 'git clone', true);
+    await execAsync(`git -C ${pushDir} clone --quiet --branch=${branchName} --depth=1 ${url} .`, true, 'git clone', true);
 
-    const clonedBranch = await getBranchName(pushDir);
-    if (branch !== clonedBranch) {
-        signale.info(`remote branch ${branch} not found.`);
-        signale.info(`now branch: ${clonedBranch}`);
+    const clonedBranch = await getCurrentBranchName(pushDir);
+    if (branchName !== clonedBranch) {
+        signale.info('remote branch %s not found.', branchName);
+        signale.info('now branch: %s', clonedBranch);
 
         await execAsync(`rm -rdf ${pushDir}`);
         fs.mkdirSync(pushDir, {recursive: true});
         await gitInit(pushDir);
-        await gitCheckout(pushDir, branch);
+        await gitCheckout(pushDir, branchName);
     }
     return true;
 };
 
-const getBranchName = async (pushDir: string): Promise<string> => {
+const getCurrentBranchName = async (pushDir: string): Promise<string> => {
     if (!fs.existsSync(path.resolve(pushDir, '.git'))) {
         return '';
     }
@@ -61,10 +64,10 @@ const gitInit = async (pushDir: string) => {
     await execAsync(`git -C ${pushDir} init .`);
 };
 
-const gitCheckout = async (pushDir: string, branch: string) => {
-    signale.info('Checking out orphan branch %s', branch);
+const gitCheckout = async (pushDir: string, branchName: string) => {
+    signale.info('Checking out orphan branch %s', branchName);
 
-    await execAsync(`git -C ${pushDir} checkout --orphan "${branch}"`);
+    await execAsync(`git -C ${pushDir} checkout --orphan "${branchName}"`);
 };
 
 const config = async (pushDir: string): Promise<boolean> => {
@@ -89,11 +92,36 @@ const commit = async (pushDir: string): Promise<boolean> => {
     return true;
 };
 
-const push = async (pushDir: string, branch: string, context: Context) => {
-    signale.info('Pushing to %s@%s', getRepository(context), branch);
+const push = async (pushDir: string, tagName: string, branchName: string, context: Context): Promise<boolean> => {
+    signale.info('Pushing to %s@%s (tag: %s)', getRepository(context), branchName, tagName);
 
     const url = getGitUrl(context);
-    await execAsync(`git -C ${pushDir} push --quiet "${url}" "${branch}":"refs/heads/${branch}"`, true, 'git push');
+    await execAsync(`git -C ${pushDir} push --delete origin tag ${tagName}`);
+    await execAsync(`git -C ${pushDir} tag -l | xargs git -C ${pushDir} tag -d`);
+    await execAsync(`git -C ${pushDir} fetch origin --tags`);
+    await execAsync(`git -C ${pushDir} tag ${tagName}`);
+    await execAsync(`git -C ${pushDir} push --quiet --tags "${url}" "${branchName}":"refs/heads/${branchName}"`, true, 'git push');
+    return true;
+};
+
+const updateRelease = async (tagName: string, octokit: GitHub, context: Context): Promise<boolean> => {
+    const releases = await octokit.repos.listReleases({
+        owner: context.repo.owner,
+        repo: context.repo.repo,
+    });
+    const release = releases.data.find(release => release.tag_name === tagName);
+    if (!release) {
+        signale.warn('There is no release that has tag name: %s', tagName);
+        return false;
+    }
+
+    await octokit.repos.updateRelease({
+        owner: context.repo.owner,
+        repo: context.repo.repo,
+        release_id: release.id,
+        draft: false,
+    });
+    return true;
 };
 
 const cloneForBuild = async (buildDir: string, context: Context) => {
@@ -127,8 +155,8 @@ const checkDiff = async (pushDir: string): Promise<boolean> => {
 };
 
 const execAsync = (command: string, quiet: boolean = false, altCommand: string | null = null, suppressError: boolean = false) => new Promise<string>((resolve, reject) => {
-    if ('string' === typeof altCommand) signale.info(`Run command: ${altCommand}`);
-    else if (!quiet) signale.info(`Run command: ${command}`);
+    if ('string' === typeof altCommand) signale.info('Run command: %s', altCommand);
+    else if (!quiet) signale.info('Run command: %s', command);
     exec(command + (quiet ? ' > /dev/null 2>&1' : '') + (suppressError ? ' || :' : ''), (error, stdout) => {
         if (error) {
             if ('string' === typeof altCommand && !quiet) reject(new Error(`command [${altCommand}] exited with code ${error.code}. message: ${error.message}`));

src/utils/misc.ts

@@ -3,7 +3,15 @@ import path from 'path';
 import yaml from 'js-yaml';
 import {getInput} from '@actions/core' ;
 import {Context} from '@actions/github/lib/context';
-import {TARGET_EVENT_NAME, TARGET_EVENT_ACTION, DEFAULT_COMMIT_MESSAGE, DEFAULT_COMMIT_NAME, DEFAULT_COMMIT_EMAIL, SEARCH_BUILD_COMMAND_TARGETS} from '../constant';
+import {
+    TARGET_EVENT_NAME,
+    TARGET_EVENT_ACTION,
+    DEFAULT_COMMIT_MESSAGE,
+    DEFAULT_COMMIT_NAME,
+    DEFAULT_COMMIT_EMAIL,
+    SEARCH_BUILD_COMMAND_TARGETS,
+    DEFAULT_BRANCH_NAME,
+} from '../constant';
 
 export const isTargetEvent = (context: Context): boolean => TARGET_EVENT_NAME === context.eventName && TARGET_EVENT_ACTION === context.payload.action;
 
@@ -51,6 +59,8 @@ export const getCommitName = (): string => getInput('COMMIT_NAME') || DEFAULT_CO
 
 export const getCommitEmail = (): string => getInput('COMMIT_EMAIL') || DEFAULT_COMMIT_EMAIL;
 
+export const getBranchName = (): string => getInput('BRANCH_NAME') || DEFAULT_BRANCH_NAME;
+
 export const getWorkspace = (): string => process.env.GITHUB_WORKSPACE || '';
 
 export const detectBuildCommand = (dir: string): boolean | string => {