add semver and automate package version bumps

Author: jasonpraful

.github/workflows/update-dependencies.yml

@@ -26,8 +26,10 @@ jobs:
         with:
           node-version: '22.14.0'
 
-      - name: 📦 Enable Corepack
-        run: corepack enable
+      - name: 📦 Enable Corepack and install semver
+        run: |
+          corepack enable
+          npm install -g [email protected]
 
       - name: 🔍 Get current dependency versions
         id: current-versions
@@ -285,11 +287,32 @@ jobs:
             git add android/build.gradle
           fi
           
+          # Determine version bump type using semver script
+          echo "📈 Analyzing version bump requirements..."
+          VERSION_BUMP_TYPE=$(node semver.js analyze \
+            "${{ steps.current-versions.outputs.ios_version }}" \
+            "${{ steps.update-analysis.outputs.ios_new_version }}" \
+            "${{ steps.current-versions.outputs.android_version }}" \
+            "${{ steps.update-analysis.outputs.android_new_version }}")
+          
+          # Get current version and increment using semver script
+          echo "📈 Applying $VERSION_BUMP_TYPE version bump..."
+          CURRENT_VERSION=$(node semver.js current)
+          NEW_VERSION=$(node semver.js inc "$CURRENT_VERSION" "$VERSION_BUMP_TYPE")
+          
+          # Update package.json version using semver script
+          node semver.js update "$NEW_VERSION"
+          
+          echo "📈 Version bumped ($VERSION_BUMP_TYPE): $CURRENT_VERSION → $NEW_VERSION"
+          git add package.json semver.js
+          
           # Update yarn.lock
           echo "📦 Installing dependencies to update lockfile..."
           yarn install --immutable
           git add yarn.lock
           
+          CHANGES="$CHANGES\\n- Bumped version from $CURRENT_VERSION to $NEW_VERSION ($VERSION_BUMP_TYPE)"
+          
           # Store for next steps
           echo "changes<<EOF" >> $GITHUB_OUTPUT
           echo -e "$CHANGES" >> $GITHUB_OUTPUT

semver.js

@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+
+const semver = require('semver');
+
+// Parse command line arguments
+const args = process.argv.slice(2);
+const command = args[0];
+
+function showHelp() {
+  console.log(`
+Usage: node semver.js <command> [arguments]
+
+Commands:
+  diff <version1> <version2>     - Compare two versions and return difference type
+  inc <version> <type>          - Increment version by type (major|minor|patch)
+  current                       - Get current version from package.json
+  
+Examples:
+  node semver.js diff 19.1.2 19.2.0     # Returns: minor
+  node semver.js inc 1.0.0 major        # Returns: 2.0.0
+  node semver.js current                 # Returns: 1.0.0
+`);
+}
+
+function getCurrentVersion() {
+  try {
+    const pkg = require('./package.json');
+    return pkg.version;
+  } catch (error) {
+    console.error('Error reading package.json:', error.message);
+    process.exit(1);
+  }
+}
+
+function updatePackageVersion(newVersion) {
+  try {
+    const fs = require('fs');
+    const pkg = require('./package.json');
+    pkg.version = newVersion;
+    fs.writeFileSync('./package.json', JSON.stringify(pkg, null, 2) + '\n');
+    return newVersion;
+  } catch (error) {
+    console.error('Error updating package.json:', error.message);
+    process.exit(1);
+  }
+}
+
+switch (command) {
+  case 'diff': {
+    const [version1, version2] = args.slice(1);
+    if (!version1 || !version2) {
+      console.error('Error: diff requires two versions');
+      process.exit(1);
+    }
+
+    // Clean versions (remove 'v' prefix if present)
+    const clean1 = version1.replace(/^v/, '');
+    const clean2 = version2.replace(/^v/, '');
+
+    try {
+      const diff = semver.diff(clean1, clean2);
+      console.log(diff || 'patch'); // Default to patch if no diff
+    } catch (error) {
+      console.error('Error comparing versions:', error.message);
+      process.exit(1);
+    }
+    break;
+  }
+
+  case 'inc': {
+    const [version, type] = args.slice(1);
+    if (!version || !type) {
+      console.error('Error: inc requires version and type (major|minor|patch)');
+      process.exit(1);
+    }
+
+    try {
+      const newVersion = semver.inc(version, type);
+      console.log(newVersion);
+    } catch (error) {
+      console.error('Error incrementing version:', error.message);
+      process.exit(1);
+    }
+    break;
+  }
+
+  case 'current': {
+    const currentVersion = getCurrentVersion();
+    console.log(currentVersion);
+    break;
+  }
+
+  case 'update': {
+    const [newVersion] = args.slice(1);
+    if (!newVersion) {
+      console.error('Error: update requires new version');
+      process.exit(1);
+    }
+
+    const result = updatePackageVersion(newVersion);
+    console.log(result);
+    break;
+  }
+
+  case 'analyze': {
+    // Special command for workflow: analyze multiple version changes and determine bump type
+    const iosOld = args[1];
+    const iosNew = args[2];
+    const androidOld = args[3];
+    const androidNew = args[4];
+
+    let bumpType = 'patch'; // Default
+
+    if (iosOld && iosNew && iosOld !== 'null' && iosNew !== 'null') {
+      const iosDiff = semver.diff(
+        iosOld.replace(/^v/, ''),
+        iosNew.replace(/^v/, '')
+      );
+      console.error(`📱 iOS: ${iosOld} → ${iosNew} (${iosDiff})`);
+
+      if (iosDiff === 'major') {
+        bumpType = 'major';
+      } else if (iosDiff === 'minor' && bumpType !== 'major') {
+        bumpType = 'minor';
+      }
+    }
+
+    if (
+      androidOld &&
+      androidNew &&
+      androidOld !== 'null' &&
+      androidNew !== 'null'
+    ) {
+      const androidDiff = semver.diff(
+        androidOld.replace(/^v/, ''),
+        androidNew.replace(/^v/, '')
+      );
+      console.error(
+        `🤖 Android: ${androidOld} → ${androidNew} (${androidDiff})`
+      );
+
+      if (androidDiff === 'major') {
+        bumpType = 'major';
+      } else if (androidDiff === 'minor' && bumpType !== 'major') {
+        bumpType = 'minor';
+      }
+    }
+
+    console.error(`📈 Determined bump type: ${bumpType}`);
+    console.log(bumpType);
+    break;
+  }
+
+  default:
+    console.error(`Unknown command: ${command}`);
+    showHelp();
+    process.exit(1);
+}