chore: release deprecation script (#3465)

* chore: migrate unpublish script -> deprecation script

* chore: add deprecation workflow

* chore: changeset

* chore: rename workflow

* chore: rebuild

* chore: use allSettled

* chore: add dry run

* chore: refactor

* chore: filter out latest next tag

* chore: remove hardcoded package

Author: danielbate

.changeset/lucky-flies-search.md

@@ -0,0 +1,4 @@
+---
+---
+
+chore: release deprecation script

.github/workflows/release-deprecate.yaml

@@ -0,0 +1,29 @@
+name: "Deprecate Old Versions"
+
+on:
+  workflow_dispatch:
+    inputs:
+      deprecate_versions:
+        type: boolean
+        description: Deprecate versions? Otherwise dry-run mode will be used.
+        default: false
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  deprecate-npm-versions:
+    name: Deprecate versions next, pr and rc
+    runs-on: buildjet-4vcpu-ubuntu-2204
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: CI Setup
+        uses: ./.github/actions/ci-setup
+
+      - name: Deprecate
+        run: pnpm release:deprecate
+        env:
+          DEPRECATE_VERSIONS: ${{ github.event.inputs.deprecate_versions }}

.github/workflows/release-unpublish.yaml

@@ -55,6 +55,7 @@
     "changeset:update-changelog": "tsx ./scripts/changeset/update-changelog.mts",
     "changeset:get-latest-release": "tsx ./scripts/changeset/get-latest-release.mts",
     "changeset:dependabot": "./scripts/changeset/dependabot-changeset.sh",
+    "release:deprecate": "tsx ./scripts/release-deprecate.ts",
     "forc:update": "tsx ./scripts/forc-update",
     "forc:check": "./scripts/forc-check.sh",
     "forc:format": "./scripts/forc-format.sh",

package.json

@@ -0,0 +1,86 @@
+import { compare } from 'compare-versions';
+import { exec } from 'node:child_process';
+import { readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+
+const { log, error } = console;
+
+const deprecateTags = /next|pr|rc/;
+const { version: currentVersion } = JSON.parse(
+  readFileSync(join(process.cwd(), '/packages/fuels/package.json')).toString()
+);
+const deprecateVersions = process.env.DEPRECATE_VERSIONS === 'true';
+
+const getPublicPackages = () => {
+  const packagesDir = join(__dirname, '../packages');
+  const packages = readdirSync(packagesDir, { withFileTypes: true });
+  const packagesNames = packages.map((p) => {
+    try {
+      const packageContent = readFileSync(join(packagesDir, p.name, 'package.json'), 'utf8');
+      const packageJson = JSON.parse(packageContent.toString());
+      return packageJson.private ? null : packageJson.name;
+    } catch (err) {
+      return null;
+    }
+  });
+  return packagesNames.filter((p) => !!p);
+};
+
+const getVersionsToDeprecate = async (packageName: string) => {
+  const { versions } = await fetch(`https://registry.npmjs.org/${packageName}`).then((resp) =>
+    resp.json()
+  );
+
+  // Only deprecate certain tags
+  const validVersions = Object.keys(versions).filter(
+    (version) => version.search(deprecateTags) > -1 && !compare(version, currentVersion, '>=')
+  );
+
+  // Remove the latest next tag from the deprecation list
+  const latestNextVersion = validVersions.filter((version) => version.search('next') > -1).pop();
+  return validVersions.filter((version) => version !== latestNextVersion);
+};
+
+const main = async () => {
+  const packages = getPublicPackages();
+  await Promise.allSettled(
+    packages.map(async (packageName) => {
+      const versionsToDeprecate = await getVersionsToDeprecate(packageName);
+
+      log('The following versions will be deprecated:');
+      log(versionsToDeprecate.map((v) => `   - ${v}`).join('\n'));
+
+      if (deprecateVersions) {
+        await Promise.allSettled(
+          versionsToDeprecate.map(
+            async (versionToDelete) =>
+              new Promise((resolve, reject) => {
+                exec(
+                  `npm deprecate ${packageName}@${versionToDelete} "Version no longer supported."`,
+                  (err, _stdout, stderr) => {
+                    if (err) {
+                      log(`❌ Error ${packageName}@${versionToDelete} not deprecated!\n`);
+                      reject(err);
+                      return;
+                    }
+                    if (stderr) {
+                      log(`❌ Error ${packageName}@${versionToDelete} not deprecated!\n`);
+                      reject(new Error(stderr));
+                      return;
+                    }
+                    log(`✅ Package ${packageName}@${versionToDelete} deprecated!\n`);
+                    resolve(true);
+                  }
+                );
+              })
+          )
+        );
+      }
+    })
+  );
+};
+
+main().catch((err) => {
+  error(err);
+  process.exit(1);
+});