Automate NPM Releases With GitHub Actions

Aug 9, 2025 by Felix Dubois 42 views

Automating NPM Package Pre-Release Versioning with GitHub Actions

Hey guys! Ever feel like the process of prepping an NPM package release is a bit too manual and repetitive? I know I have! That's why I'm super excited to share how we can automate the creation of pre-release versions using GitHub Actions. This is a game-changer for streamlining your workflow and making your life as a developer a whole lot easier. Let's dive into how we can achieve this!

The Pain Points of Manual NPM Releases

Before we jump into the solution, let's quickly recap the manual steps that often bog us down during monthly NPM releases. Currently, the process involves several manual tasks that, while seemingly small, can add up and introduce opportunities for human error. These steps typically include:

Running npm version <major|minor|patch>: This command is crucial for bumping the package version, but it requires manual execution and the correct choice of version increment.
Bumping the version in index.js: Ensuring the version in your main file matches the package version is vital, but it's another manual step prone to oversight.
Running basic sanity tests with npm ci and npm test: Sanity checks are essential, but manually running these commands can be time-consuming.

These manual steps, while necessary, can be streamlined and automated to save time and reduce the risk of errors. By automating these processes, we can focus on more critical tasks and ensure a smoother release cycle.

Why Automate NPM Package Releases?

Automating NPM package releases isn't just about saving a few minutes here and there; it's about creating a more efficient, reliable, and less error-prone workflow. Think about it – by automating the release process, you're not just reducing the manual effort involved; you're also ensuring consistency and accuracy. This means fewer late-night bug hunts and more time spent on actually building cool stuff. Automation also makes the release process more predictable and repeatable, which is crucial for maintaining a consistent release cadence. Plus, it frees you up to focus on the more strategic aspects of your project, like feature development and user feedback.

Imagine this: instead of spending an hour manually bumping versions, running tests, and creating pull requests, you simply trigger a workflow and let the magic happen. That's the power of automation! And that's exactly what we're going to build with GitHub Actions.

Benefits of Automation

Reduced Manual Effort: Automate repetitive tasks, freeing up valuable time for more important work.
Improved Consistency: Ensure every release follows the same process, reducing the risk of errors.
Faster Release Cycles: Speed up the release process, allowing for more frequent updates.
Increased Reliability: Minimize human error, resulting in more stable releases.
Enhanced Collaboration: Make the release process more transparent and accessible to the team.

The Goal: A Manually Triggered GitHub Action

Our mission, should we choose to accept it, is to create a manually triggered GitHub Action that automates the pre-release versioning process. This action should give us the flexibility to choose between a major, minor, or patch version bump. Once triggered, the action will handle the following:

Bump the version in package.json using npm version. This ensures that the package version is correctly updated according to the chosen increment.
Update the version in index.js (or your main entry point file) to match the new package version. This is crucial for consistency and ensures that the application uses the correct version.
Run basic sanity testing with npm ci and npm test. These tests help catch any potential issues early in the release process.
Create a new branch named release/x.y.z (where x.y.z is the new version number). This branch will house the changes related to the release.
Commit the changes to the release/x.y.z branch. This creates a clear record of the changes made for the release.
Open a pull request (PR) against the default branch of the repository. This allows for review and approval before merging the changes into the main codebase.

The manual step in this process will be the review and merge of the pull request. This ensures that a human eye is always involved before a release is finalized.

Prerequisite: Setting the Stage for Automation

Before diving into the GitHub Actions code, it's essential to understand the groundwork we're laying. The key here is to establish a clear and repeatable process for managing releases. This involves not just the technical aspects of version bumping and file updates but also the organizational structure of our repository. For instance, having a well-defined main or develop branch as our default allows the automation to seamlessly create release branches and target pull requests appropriately. Similarly, ensuring that our index.js or main entry point consistently reflects the package version is crucial for the automation to function correctly. Think of this setup as building the launchpad for our automated rocket – without a solid base, the automation, however brilliant, won't reach its full potential.

Furthermore, let's consider the importance of testing in this automated process. By integrating npm ci and npm test, we're not just running commands; we're establishing a safety net. These tests act as gatekeepers, preventing releases with obvious bugs from ever making it to the public. This proactive approach to quality control is a cornerstone of a robust release pipeline. So, before we write a single line of YAML for our GitHub Action, let's appreciate the significance of these foundational steps in setting up a reliable and efficient automated release system.

Crafting the GitHub Action Workflow

Okay, let's get our hands dirty and build this awesome GitHub Action! We'll need to create a new workflow file in our repository. Create a new file in .github/workflows directory, for example, release.yml. Here’s the breakdown of the workflow:

Workflow Structure: Dissecting the YAML

name: Create Pre-Release Version

on:
  workflow_dispatch:
    inputs:
      version_bump:
        description: 'Version bump (major, minor, patch)'
        required: true
        type: choice
        options: 
          - major
          - minor
          - patch

jobs:
  release:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Set up Node.js
        uses: actions/setup-node@v3
        with:
          node-version: 16
      - name: Get current version
        id: get_version
        run: echo "::set-output name=current_version::$(node -p \