improve beta release ci

MQ37 · MQ37 · commit 70d2c38b633f · 2025-08-04T10:33:56.000+02:00
diff --git a/.github/scripts/before-beta-release.cjs b/.github/scripts/before-beta-release.cjs
@@ -1,33 +1,132 @@
+/* eslint-disable no-console */
 const { execSync } = require('node:child_process');
 const fs = require('node:fs');
 const path = require('node:path');
 
 const PKG_JSON_PATH = path.join(__dirname, '..', '..', 'package.json');
 
-const pkgJson = require(PKG_JSON_PATH); // eslint-disable-line import/no-dynamic-require
-
-const PACKAGE_NAME = pkgJson.name;
-const VERSION = pkgJson.version;
-console.log(`before-deploy: Current version is ${VERSION}`); // eslint-disable-line no-console
+function execCommand(command, options = {}) {
+    try {
+        return execSync(command, { encoding: 'utf8', ...options }).trim();
+    } catch (error) {
+        console.error(`Command failed: ${command}`);
+        console.error(error.message);
+        process.exit(1);
+        return null; // Ensure a return value for all code paths
+    }
+}
 
-const nextVersion = getNextVersion(VERSION);
-console.log(`before-deploy: Setting version to ${nextVersion}`); // eslint-disable-line no-console
-pkgJson.version = nextVersion;
+function getPackageInfo() {
+    const pkgJson = JSON.parse(fs.readFileSync(PKG_JSON_PATH, 'utf8'));
+    return {
+        name: pkgJson.name,
+        version: pkgJson.version,
+        pkgJson,
+    };
+}
 
-fs.writeFileSync(PKG_JSON_PATH, `${JSON.stringify(pkgJson, null, 2)}\n`);
+function getBaseVersionFromGit() {
+    try {
+        // Get the base version from the latest commit that updated package.json
+        // This ensures we use the version that was set by the release_metadata step
+        const gitShow = execCommand('git show HEAD:package.json');
+        const gitPackageJson = JSON.parse(gitShow);
+        return gitPackageJson.version;
+    } catch (error) {
+        console.error('Could not get base version from git');
+        throw error;
+    }
+}
 
-function getNextVersion(version) {
-    const versionString = execSync(`npm show ${PACKAGE_NAME} versions --json`, { encoding: 'utf8' });
-    const versions = JSON.parse(versionString);
+function getNextBetaVersion(packageName, baseVersion) {
+    console.log(`Calculating next beta version for base: ${baseVersion}`);
 
-    if (versions.some((v) => v === VERSION)) {
-        console.error(`before-deploy: A release with version ${VERSION} already exists. Please increment version accordingly.`); // eslint-disable-line no-console
+    // Validate base version format
+    if (!/^\d+\.\d+\.\d+$/.test(baseVersion)) {
+        console.error(`Invalid base version format: ${baseVersion}`);
         process.exit(1);
     }
 
-    const prereleaseNumbers = versions
-        .filter((v) => (v.startsWith(VERSION) && v.includes('-')))
-        .map((v) => Number(v.match(/\.(\d+)$/)[1]));
-    const lastPrereleaseNumber = Math.max(-1, ...prereleaseNumbers);
-    return `${version}-beta.${lastPrereleaseNumber + 1}`;
+    let npmBetaNumber = 0;
+    let gitBetaNumber = 0;
+
+    // Check NPM for existing beta versions
+    try {
+        const versionString = execCommand(`npm show ${packageName} versions --json`);
+        const versions = JSON.parse(versionString);
+
+        // Check if base version already exists as stable
+        if (versions.includes(baseVersion)) {
+            console.error(`Base version ${baseVersion} already exists as stable on NPM!`);
+            process.exit(1);
+        }
+
+        const versionPrefix = `${baseVersion}-beta.`;
+        const npmBetas = versions
+            .filter((v) => v.startsWith(versionPrefix))
+            .map((v) => {
+                const match = v.match(/^.+-beta\.(\d+)$/);
+                return match ? parseInt(match[1], 10) : 0;
+            });
+
+        npmBetaNumber = npmBetas.length > 0 ? Math.max(...npmBetas) : 0;
+        console.log(`Latest beta on NPM: ${npmBetaNumber}`);
+    } catch {
+        console.log('No existing versions found on NPM');
+    }
+
+    // Check Git tags for existing beta versions
+    try {
+        const tagPattern = `v${baseVersion}-beta.*`;
+        const tags = execCommand(`git tag -l "${tagPattern}" --sort=-version:refname`);
+
+        if (tags) {
+            const tagList = tags.split('\n').filter((tag) => tag.trim());
+            if (tagList.length > 0) {
+                const latestTag = tagList[0];
+                const match = latestTag.match(/v\d+\.\d+\.\d+-beta\.(\d+)$/);
+                if (match) {
+                    gitBetaNumber = parseInt(match[1], 10);
+                    console.log(`Latest beta in Git: ${gitBetaNumber}`);
+                }
+            }
+        }
+    } catch {
+        console.log('No existing beta tags found in Git');
+    }
+
+    // Use the higher number to avoid conflicts
+    const nextBetaNumber = Math.max(npmBetaNumber, gitBetaNumber) + 1;
+    const nextVersion = `${baseVersion}-beta.${nextBetaNumber}`;
+
+    console.log(`Next beta version: ${nextVersion}`);
+    return nextVersion;
 }
+
+function updatePackageVersion(newVersion) {
+    const { pkgJson } = getPackageInfo();
+    pkgJson.version = newVersion;
+    fs.writeFileSync(PKG_JSON_PATH, `${JSON.stringify(pkgJson, null, 2)}\n`);
+    console.log(`Updated package.json to ${newVersion}`);
+}
+
+function main() {
+    console.log('🚀 Starting beta version calculation...');
+
+    const { name: packageName } = getPackageInfo();
+
+    // Get the base version from Git (what was committed by release_metadata)
+    const baseVersion = getBaseVersionFromGit();
+    console.log(`Base version from Git: ${baseVersion}`);
+
+    // Calculate next beta version
+    const nextBetaVersion = getNextBetaVersion(packageName, baseVersion);
+
+    // Update package.json with the beta version
+    updatePackageVersion(nextBetaVersion);
+
+    console.log('✅ Beta version preparation completed!');
+    console.log(`Package will be published as: ${nextBetaVersion}`);
+}
+
+main();
diff --git a/.github/workflows/pre_release.yaml b/.github/workflows/pre_release.yaml
@@ -1,21 +1,18 @@
 name: Create a pre-release
 
 on:
-    workflow_dispatch:
-    # Push to master will deploy a beta version
-    push:
-        branches:
-            - master
-        tags-ignore:
-            - "**" # Ignore all tags to prevent duplicate builds when tags are pushed.
+    # Only trigger on PRs with "beta" label
+    pull_request:
+        types: [labeled, synchronize, reopened]
 
 concurrency:
     group: release
     cancel-in-progress: false
 
 jobs:
     release_metadata:
-        if: "!startsWith(github.event.head_commit.message, 'docs') && !startsWith(github.event.head_commit.message, 'ci') && startsWith(github.repository, 'apify/')"
+        # Run ONLY when PR has the "beta" label
+        if: contains(github.event.pull_request.labels.*.name, 'beta')
         name: Prepare release metadata
         runs-on: ubuntu-latest
         outputs:
@@ -40,12 +37,13 @@ jobs:
                     check-regexp: (Code checks)
                     wait-interval: 5
 
-    update_changelog:
+    update_changelog_and_version:
         needs: [ release_metadata, wait_for_checks ]
-        name: Update changelog
+        name: Update changelog and prepare beta version
         runs-on: ubuntu-latest
         outputs:
             changelog_commitish: ${{ steps.commit.outputs.commit_long_sha || github.sha }}
+            beta_version: ${{ steps.beta_version.outputs.version }}
 
         steps:
             -   name: Checkout repository
@@ -57,10 +55,25 @@ jobs:
                 uses: actions/setup-node@v4
                 with:
                     node-version: 22
+                    cache: 'npm'
+                    cache-dependency-path: 'package-lock.json'
 
-            -   name: Update package version in package.json
+            -   name: Install dependencies
+                run: npm ci
+
+            -   name: Update package version to base version
                 run: npm version --no-git-tag-version --allow-same-version ${{ needs.release_metadata.outputs.version_number }}
 
+            -   name: Calculate and set beta version
+                id: beta_version
+                run: |
+                    # Use the improved beta script
+                    node ./.github/scripts/before-beta-release.cjs
+                    # Output the version for later jobs
+                    BETA_VERSION=$(node -p "require('./package.json').version")
+                    echo "version=$BETA_VERSION" >> $GITHUB_OUTPUT
+                    echo "Beta version: $BETA_VERSION"
+
             -   name: Update CHANGELOG.md
                 uses: DamianReeves/write-file-action@master
                 with:
@@ -74,32 +87,48 @@ jobs:
                 with:
                     author_name: Apify Release Bot
                     author_email: noreply@apify.com
-                    message: "chore(release): Update changelog and package version [skip ci]"
+                    message: "chore(release): Update to ${{ steps.beta_version.outputs.version }} [skip ci]"
+
+            -   name: Create and push beta tag
+                run: |
+                    git tag "v${{ steps.beta_version.outputs.version }}"
+                    git push origin "v${{ steps.beta_version.outputs.version }}"
 
     publish_to_npm:
         name: Publish to NPM
-        needs: [ release_metadata, wait_for_checks ]
+        needs: [ update_changelog_and_version ]
         runs-on: ubuntu-latest
         steps:
             -   uses: actions/checkout@v4
                 with:
-                    ref: ${{ needs.update_changelog.changelog_commitish }}
+                    ref: ${{ needs.update_changelog_and_version.outputs.changelog_commitish }}
+                    
             -   name: Use Node.js 22
                 uses: actions/setup-node@v4
                 with:
                     node-version: 22
                     cache: 'npm'
                     cache-dependency-path: 'package-lock.json'
+                    
             -   name: Install dependencies
                 run: |
                     echo "access=public" >> .npmrc
                     echo "//registry.npmjs.org/:_authToken=${NPM_TOKEN}" >> .npmrc
                     npm ci
-            - # Check version consistency and increment pre-release version number for beta only.
-                name: Bump pre-release version
-                run: node ./.github/scripts/before-beta-release.cjs
+                    
+            -   name: Verify version consistency
+                run: |
+                    PACKAGE_VERSION=$(node -p "require('./package.json').version")
+                    EXPECTED_VERSION="${{ needs.update_changelog_and_version.outputs.beta_version }}"
+                    if [ "$PACKAGE_VERSION" != "$EXPECTED_VERSION" ]; then
+                        echo "Version mismatch! Package: $PACKAGE_VERSION, Expected: $EXPECTED_VERSION"
+                        exit 1
+                    fi
+                    echo "Version verified: $PACKAGE_VERSION"
+                    
             -   name: Build module
                 run: npm run build
+                    
             -   name: Publish to NPM
                 run: npm publish --tag beta
 
