feat: improve release

MartianGreed · MartianGreed · commit 31a5f2b87f4e · 2025-07-09T16:37:54.000+02:00
diff --git a/.changeset/config.json b/.changeset/config.json
@@ -4,7 +4,7 @@
   "commit": false,
   "fixed": [],
   "linked": [],
-  "access": "restricted",
+  "access": "public",
   "baseBranch": "main",
   "updateInternalDependencies": "patch",
   "ignore": [
diff --git a/.github/workflows/release.yaml b/.github/workflows/release.yaml
@@ -4,9 +4,20 @@ on:
   workflow_dispatch:
     inputs:
       release_type:
-        description: "Type of release (prerelease, prepatch, patch, minor, preminor, major)"
+        description: "Type of release (auto, prerelease, patch, minor, major)"
         required: true
-        default: "patch"
+        default: "auto"
+        type: choice
+        options:
+          - auto
+          - prerelease
+          - patch
+          - minor
+          - major
+      prerelease_tag:
+        description: "Prerelease tag (e.g., rc, beta, alpha) - only used for prerelease"
+        required: false
+        default: "rc"
       dry_run:
         description: "Dry run (no actual publishing or commits)"
         required: false
@@ -21,6 +32,7 @@ jobs:
         with:
           submodules: true
           token: ${{ secrets.GITHUB_TOKEN }}
+          fetch-depth: 0
 
       - uses: pnpm/action-setup@v3
         with:
@@ -89,9 +101,38 @@ jobs:
           git config user.name "${{ github.actor }}"
           git config user.email "${{ github.actor }}@users.noreply.github.com"
 
-      - name: "Setup npm for npmjs"
+      - name: Determine release strategy
+        id: release-strategy
+        run: |
+          CURRENT_BRANCH=$(git rev-parse --abbrev-ref HEAD)
+          echo "Current branch: $CURRENT_BRANCH"
+          
+          # Determine if we should use prerelease mode
+          if [[ "$CURRENT_BRANCH" != "main" && "${{ github.event.inputs.release_type }}" == "auto" ]]; then
+            echo "Non-main branch detected, will use prerelease mode"
+            echo "use_prerelease=true" >> $GITHUB_OUTPUT
+            
+            # Extract version from branch name if it's a release branch
+            if [[ "$CURRENT_BRANCH" =~ ^release/([0-9]+\.[0-9]+) ]]; then
+              echo "prerelease_tag=${BASH_REMATCH[1]}-rc" >> $GITHUB_OUTPUT
+            else
+              # Use branch name as prerelease tag (sanitized)
+              SANITIZED_BRANCH=$(echo "$CURRENT_BRANCH" | sed 's/[^a-zA-Z0-9-]/-/g')
+              echo "prerelease_tag=$SANITIZED_BRANCH" >> $GITHUB_OUTPUT
+            fi
+          elif [[ "${{ github.event.inputs.release_type }}" == "prerelease" ]]; then
+            echo "Manual prerelease requested"
+            echo "use_prerelease=true" >> $GITHUB_OUTPUT
+            echo "prerelease_tag=${{ github.event.inputs.prerelease_tag }}" >> $GITHUB_OUTPUT
+          else
+            echo "Standard release mode"
+            echo "use_prerelease=false" >> $GITHUB_OUTPUT
+          fi
+
+      - name: "Setup npm authentication"
         run: |
           npm config set registry https://registry.npmjs.org/
+          npm config set //registry.npmjs.org/:_authToken=${{ secrets.NPM_TOKEN }}
           echo "//registry.npmjs.org/:_authToken=${{ secrets.NPM_TOKEN }}" > ~/.npmrc
 
       - name: Install Protobuf Compiler
@@ -100,87 +141,141 @@ jobs:
       - name: Install dependencies
         run: pnpm install
 
-      - name: Check for packages to be bumped
-        id: check-status
+      - name: Enter prerelease mode if needed
+        if: steps.release-strategy.outputs.use_prerelease == 'true'
+        run: |
+          PRERELEASE_TAG="${{ steps.release-strategy.outputs.prerelease_tag }}"
+          echo "Entering prerelease mode with tag: $PRERELEASE_TAG"
+          
+          if [ "${{ github.event.inputs.dry_run }}" != "true" ]; then
+            pnpm changeset pre enter "$PRERELEASE_TAG"
+          else
+            echo "DRY RUN: Would enter prerelease mode with tag $PRERELEASE_TAG"
+          fi
+
+      - name: Check for changesets
+        id: check-changesets
         run: |
-          # Run changeset status and capture output
-          STATUS=$(pnpm changeset status)
-          echo "Changeset status:"
-          echo "$STATUS"
-
-          # Check if we have packages to bump
-          if echo "$STATUS" | grep -q "NO packages to be bumped at patch" && \
-             echo "$STATUS" | grep -q "NO packages to be bumped at minor" && \
-             echo "$STATUS" | grep -q "NO packages to be bumped at major"; then
-            echo "No packages need to be bumped at any level. Exiting workflow."
-            echo "has_changes=false" >> $GITHUB_OUTPUT
+          # Check if there are any changesets
+          if [ -z "$(ls -A .changeset/*.md 2>/dev/null | grep -v README.md)" ]; then
+            echo "No changesets found. Nothing to release."
+            echo "has_changesets=false" >> $GITHUB_OUTPUT
             exit 0
           else
-            echo "Found packages that need to be bumped. Continuing workflow."
-            echo "has_changes=true" >> $GITHUB_OUTPUT
+            echo "Found changesets to process."
+            echo "has_changesets=true" >> $GITHUB_OUTPUT
           fi
 
       - name: Version packages
+        if: steps.check-changesets.outputs.has_changesets == 'true'
         id: changesets-version
         run: |
-          # Apply version bump based on release type
-          pnpm changeset version
-
-          # If this is a dry run, revert the version changes
-          if [ "${{ github.event.inputs.dry_run }}" == "true" ]; then
-            echo "DRY RUN: Would version packages to ${NEW_VERSION}"
-            git checkout -- .
+          echo "Running changeset version..."
+          
+          if [ "${{ github.event.inputs.dry_run }}" != "true" ]; then
+            pnpm changeset version
+            
+            # If we're in prerelease mode and on a non-main branch, we might need to force version bumps
+            if [ "${{ steps.release-strategy.outputs.use_prerelease }}" == "true" ]; then
+              echo "Prerelease versioning completed"
+            fi
+          else
+            echo "DRY RUN: Would run changeset version"
+            # Show what would be versioned
+            pnpm changeset status --verbose
           fi
 
       - name: Commit changes
-        if: ${{ github.event.inputs.dry_run != 'true' }}
+        if: ${{ github.event.inputs.dry_run != 'true' && steps.check-changesets.outputs.has_changesets == 'true' }}
         run: |
           if git diff --quiet && git diff --staged --quiet; then
             echo "No changes to commit"
           else
             git add .
             git commit -m "chore: release"
-            git push origin refs/heads/main:refs/heads/main
+            
+            # Push to the current branch
+            CURRENT_BRANCH=$(git rev-parse --abbrev-ref HEAD)
+            git push origin "refs/heads/$CURRENT_BRANCH:refs/heads/$CURRENT_BRANCH"
           fi
 
       - name: Publish to npm
-        if: ${{ github.event.inputs.dry_run != 'true' }}
-        run: pnpm release
+        if: ${{ github.event.inputs.dry_run != 'true' && steps.check-changesets.outputs.has_changesets == 'true' }}
+        run: |
+          echo "Publishing packages..."
+          # Changesets will only publish packages that are not ignored in config
+          pnpm changeset publish
         env:
           NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
 
       - name: Dry run - Show npm publish
-        if: ${{ github.event.inputs.dry_run == 'true' }}
+        if: ${{ github.event.inputs.dry_run == 'true' && steps.check-changesets.outputs.has_changesets == 'true' }}
         run: |
           echo "DRY RUN: Would publish the following packages to npm:"
-          pnpm release:dry-run
+          # Show what changesets would publish
+          pnpm changeset publish --dry-run
+        env:
+          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
 
-      - name: Create and push tag
-        if: ${{ github.event.inputs.dry_run != 'true' }}
+      - name: Create and push tags
+        if: ${{ github.event.inputs.dry_run != 'true' && steps.check-changesets.outputs.has_changesets == 'true' }}
         run: |
+          echo "Creating tags..."
           pnpm changeset tag
           git push --tags
           
+      - name: Exit prerelease mode if needed
+        if: steps.release-strategy.outputs.use_prerelease == 'true' && github.event.inputs.dry_run != 'true' && steps.check-changesets.outputs.has_changesets == 'true'
+        run: |
+          echo "Exiting prerelease mode"
+          pnpm changeset pre exit || true
+          
+          # Commit the pre.json removal if it exists
+          if [ -f .changeset/pre.json ]; then
+            git add .changeset/pre.json
+            git commit -m "chore: exit prerelease mode" || true
+            CURRENT_BRANCH=$(git rev-parse --abbrev-ref HEAD)
+            git push origin "refs/heads/$CURRENT_BRANCH:refs/heads/$CURRENT_BRANCH" || true
+          fi
+
       - name: Trigger release creation
-        if: ${{ github.event.inputs.dry_run != 'true' }}
+        if: ${{ github.event.inputs.dry_run != 'true' && steps.check-changesets.outputs.has_changesets == 'true' }}
         run: |
           # Get all tags that were just created
           TAGS=$(git tag --points-at HEAD | grep '@dojoengine/' || true)
           
           # For each tag, trigger the release workflow
+          CURRENT_BRANCH=$(git rev-parse --abbrev-ref HEAD)
           for TAG in $TAGS; do
             echo "Triggering release for tag: $TAG"
             gh workflow run create_release.yaml \
-              --ref main \
+              --ref "$CURRENT_BRANCH" \
               -f tag="$TAG"
           done
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
-      - name: Dry run - Show git changes
-        if: ${{ github.event.inputs.dry_run == 'true' }}
+      - name: Dry run - Summary
+        if: ${{ github.event.inputs.dry_run == 'true' && steps.check-changesets.outputs.has_changesets == 'true' }}
         run: |
-          TAGS=$(pnpm changeset tag)
-          echo "DRY RUN: Would commit changes with message: chore: release"
-          echo "DRY RUN: Would create and push tag: $TAGS"
+          echo "DRY RUN SUMMARY:"
+          echo "================"
+          
+          if [ "${{ steps.release-strategy.outputs.use_prerelease }}" == "true" ]; then
+            echo "Would enter prerelease mode: ${{ steps.release-strategy.outputs.prerelease_tag }}"
+          fi
+          
+          echo "Would version packages according to changesets"
+          echo "Would commit with message: chore: release"
+          echo "Would create and push tags"
+          echo "Would publish packages to npm"
+          
+          if [ "${{ steps.release-strategy.outputs.use_prerelease }}" == "true" ]; then
+            echo "Would exit prerelease mode after publishing"
+          fi
+          
+          echo ""
+          echo "Current git status:"
           git status
diff --git a/RELEASE_PROCESS.md b/RELEASE_PROCESS.md
@@ -0,0 +1,119 @@
+# Release Process with Changesets
+
+This repository uses [Changesets](https://github.com/changesets/changesets) to manage versions and releases across multiple packages, with support for different versioning strategies on different branches.
+
+## Overview
+
+- **Main branch**: Stable releases (1.5.0, 1.6.0, etc.)
+- **Release branches** (`release/*`): Patch releases and release candidates
+- **Feature branches**: Prerelease versions for testing
+
+## Creating Changesets
+
+When you make changes that should be included in a release:
+
+```bash
+pnpm changeset
+```
+
+This will prompt you to:
+1. Select which packages have changed
+2. Choose the version bump type (major, minor, patch)
+3. Write a summary for the changelog
+
+## Release Workflow
+
+### Automatic Branch Detection
+
+The release workflow automatically detects your branch and applies the appropriate versioning strategy:
+
+- On `main`: Standard releases
+- On `release/*`: Prereleases with RC tags (e.g., 1.6.0-rc.0)
+- On other branches: Prereleases with branch name tags
+
+### Manual Release Process
+
+1. **Trigger the Release Workflow**
+   - Go to Actions → "Publish packages and create tags"
+   - Click "Run workflow"
+   - Select options:
+     - `release_type`: Choose "auto" for automatic detection or specify manually
+     - `prerelease_tag`: Custom tag for prereleases (default: "rc")
+     - `dry_run`: Test the release without publishing
+
+2. **What Happens**
+   - Changesets are consumed and versions are bumped
+   - For non-main branches: Enters prerelease mode automatically
+   - Commits version changes
+   - Publishes to npm
+   - Creates git tags
+   - Triggers GitHub releases
+
+### Release Types
+
+- **auto**: Automatically determines strategy based on branch
+- **prerelease**: Force prerelease mode with custom tag
+- **patch/minor/major**: Force specific version bump
+
+## Branch Strategies
+
+### Main Branch
+Standard releases following semver:
+```
+1.5.0 → 1.6.0 (minor)
+1.6.0 → 1.6.1 (patch)
+1.6.1 → 2.0.0 (major)
+```
+
+### Release Branches
+For maintenance and release candidates:
+```
+release/1.6 → 1.6.0-rc.0 → 1.6.0-rc.1 → 1.6.0
+release/1.5 → 1.5.1, 1.5.2 (patches only)
+```
+
+### Feature Branches
+For testing features before merge:
+```
+feat/new-api → 1.7.0-feat-new-api.0
+fix/bug-123 → 1.6.1-fix-bug-123.0
+```
+
+## Local Commands
+
+```bash
+# Create a changeset
+pnpm changeset
+
+# Version packages locally (consumes changesets)
+pnpm version
+
+# Publish to npm (after versioning)
+pnpm release
+
+# Dry run to see what would be published
+pnpm release:dry-run
+```
+
+## Best Practices
+
+1. **Always create changesets** for changes that affect the public API
+2. **Use conventional commit messages** for better tracking
+3. **Test prereleases** on feature/release branches before merging
+4. **Don't commit version changes manually** - let the workflow handle it
+5. **Review changeset summaries** - they become your changelog
+
+## Troubleshooting
+
+### No packages to release
+- Ensure you have uncommitted changesets in `.changeset/`
+- Check that packages aren't ignored in `.changeset/config.json`
+
+### Prerelease versions not working
+- Verify you're not on the main branch
+- Check if `.changeset/pre.json` exists (indicates prerelease mode)
+
+### Version conflicts
+- Don't manually edit package.json versions
+- Let changesets handle all version bumps
+- If needed, delete `.changeset/pre.json` and start fresh
diff --git a/package.json b/package.json
@@ -10,8 +10,10 @@
         "prettier-check": "pnpx prettier --check packages examples",
         "format": "turbo format",
         "format:check": "turbo format:check",
-        "release": "pnpm build:deps && pnpm -F './packages/**' publish -r --force --no-git-checks",
-        "release:dry-run": "pnpm -F './packages/**' publish -r --force --dry-run",
+        "changeset": "changeset",
+        "version": "changeset version",
+        "release": "pnpm build:deps && changeset publish",
+        "release:dry-run": "pnpm build:deps && changeset publish --dry-run",
         "dev": "turbo watch dev --concurrency 20",
         "dev:deps": "turbo watch build:deps --concurrency 20",
         "docs": "turbo run docs --ui stream && typedoc --entryPointStrategy merge 'docs-json/*.json'",
