feat(scripts): compute eligibility dates

scripts/cli/index.ts

@@ -12,7 +12,6 @@ import { formatter } from '../formatter.js';
 import { generate } from '../generate.js';
 import { playground } from '../playground.js';
 import { createReleasePR } from '../release/createReleasePR.js';
-import { generateVersionsHistory } from '../release/versionsHistory.js';
 import { buildSpecs } from '../specs/index.js';
 import type { Language } from '../types.js';
 
@@ -308,16 +307,11 @@ program
   .action(async ({ verbose, releaseType, dryRun, versionsHistory, breaking }) => {
     setVerbose(Boolean(verbose));
 
-    if (versionsHistory) {
-      await generateVersionsHistory({});
-
-      return;
-    }
-
     await createReleasePR({
       releaseType,
       dryRun,
       breaking,
+      versionsHistory,
     });
   });
 

scripts/release/__tests__/createReleasePR.test.ts

@@ -283,22 +283,22 @@ describe('createReleasePR', () => {
         ],
       });
 
-      expect(versions).toEqual({
-        java: {
-          current: '0.1.2',
-          next: '0.2.0',
-          releaseType: 'minor',
-        },
-        javascript: {
-          current: '0.1.2',
-          next: '0.2.0',
-          releaseType: 'minor',
-        },
-        php: {
-          current: '0.1.2',
-          next: '0.2.0',
-          releaseType: 'minor',
-        },
+      expect(versions.java).toEqual({
+        current: '0.1.2',
+        next: '0.2.0',
+        releaseType: 'minor',
+      });
+
+      expect(versions.javascript).toEqual({
+        current: '0.1.2',
+        next: '0.2.0',
+        releaseType: 'minor',
+      });
+
+      expect(versions.php).toEqual({
+        current: '0.1.2',
+        next: '0.2.0',
+        releaseType: 'minor',
       });
     });
   });

scripts/release/__tests__/versionsHistory.test.ts

@@ -20,43 +20,65 @@ describe('generateLanguageVersionsHistory', () => {
       expect(versions).toEqual({
         '1.2.4': {
           releaseDate: '2023-12-28',
+          eligibilityDate: undefined,
+          eligibilityStatus: 'eligible',
         },
         '1.2.5': {
           releaseDate: '2024-01-02',
+          eligibilityDate: undefined,
+          eligibilityStatus: 'eligible',
         },
         '1.2.6': {
           releaseDate: '2024-01-02',
+          eligibilityDate: undefined,
+          eligibilityStatus: 'eligible',
         },
         '1.2.7': {
           releaseDate: '2024-01-04',
+          eligibilityDate: undefined,
+          eligibilityStatus: 'eligible',
         },
       });
     });
 
     it('parses version of different same minor', () => {
       const versions = generateLanguageVersionsHistory(
         [
-          '1.1.4 Thu Dec 28 15:48:25 2023 +0000',
-          '1.2.5 Tue Jan 2 14:17:11 2024 +0000',
-          '1.3.6 Tue Jan 2 15:26:06 2024 +0000',
-          '1.4.7 Thu Jan 4 15:09:11 2024 +0000',
+          '1.1.4 Thu Dec 28 15:48:25 2022 +0000',
+          '2.1.2 Tue Jan 2 14:17:11 2022 +0000',
+          '2.2.5 Tue Jan 2 14:17:11 2024 +0000',
+          '2.3.6 Tue Jan 2 15:26:06 2024 +0000',
+          '3.4.7 Thu Jan 4 15:09:11 2024 +0000',
         ],
         'javascript',
-        { current: '1.4.7', next: null, releaseType: null },
+        { current: '3.4.7', next: null, releaseType: null },
       );
 
       expect(versions).toEqual({
         '1.1.4': {
-          releaseDate: '2023-12-28',
+          releaseDate: '2022-12-28',
+          eligibilityDate: undefined,
+          eligibilityStatus: 'not eligible',
         },
-        '1.2.5': {
+        '2.1.2': {
+          releaseDate: '2022-01-02',
+          eligibilityDate: '2026-08-14',
+          eligibilityStatus: 'replaced',
+        },
+        '2.2.5': {
           releaseDate: '2024-01-02',
+          eligibilityDate: '2026-08-14',
+          eligibilityStatus: 'replaced',
         },
-        '1.3.6': {
+        '2.3.6': {
           releaseDate: '2024-01-02',
+          eligibilityDate: '2026-08-14',
+          eligibilityStatus: 'replaced',
         },
-        '1.4.7': {
+        '3.4.7': {
           releaseDate: '2024-01-04',
+          eligibilityDate: undefined,
+          eligibilityStatus: 'eligible',
         },
       });
     });
@@ -77,6 +99,8 @@ describe('generateLanguageVersionsHistory', () => {
       expect(versions).toEqual({
         '1.2.4': {
           releaseDate: '2023-12-28',
+          eligibilityDate: undefined,
+          eligibilityStatus: 'eligible',
         },
       });
     });
@@ -91,9 +115,13 @@ describe('generateLanguageVersionsHistory', () => {
       expect(versions).toEqual({
         '1.2.4': {
           releaseDate: '2023-12-28',
+          eligibilityDate: undefined,
+          eligibilityStatus: 'eligible',
         },
         '2.0.0': {
           releaseDate: start.toISOString().split('T')[0],
+          eligibilityDate: undefined,
+          eligibilityStatus: 'eligible',
         },
       });
     });
@@ -108,9 +136,13 @@ describe('generateLanguageVersionsHistory', () => {
       expect(versions).toEqual({
         '1.2.4': {
           releaseDate: '2023-12-28',
+          eligibilityDate: undefined,
+          eligibilityStatus: 'eligible',
         },
         '1.3.0': {
           releaseDate: start.toISOString().split('T')[0],
+          eligibilityDate: undefined,
+          eligibilityStatus: 'eligible',
         },
       });
     });
@@ -125,9 +157,13 @@ describe('generateLanguageVersionsHistory', () => {
       expect(versions).toEqual({
         '1.2.4': {
           releaseDate: '2023-12-28',
+          eligibilityDate: undefined,
+          eligibilityStatus: 'eligible',
         },
         '1.2.5': {
           releaseDate: start.toISOString().split('T')[0],
+          eligibilityDate: undefined,
+          eligibilityStatus: 'eligible',
         },
       });
     });

scripts/release/createReleasePR.ts

@@ -204,6 +204,8 @@ export function decideReleaseStrategy({
     if (relevantCommits.length === 0) {
       console.log(`    > Skipping, no commits found for ${lang}.`);
 
+      versionsToPublish[lang] = { current: currentVersion };
+
       continue;
     }
 
@@ -304,18 +306,20 @@ async function getCommits(force?: boolean): Promise<{
 /**
  * Ensure the release environment is correct before triggering.
  */
-async function prepareGitEnvironment(): Promise<void> {
-  ensureGitHubToken();
+async function prepareGitEnvironment(dryRun: boolean): Promise<void> {
+  if (!dryRun) {
+    ensureGitHubToken();
+  }
 
-  if (CI) {
+  if (CI && !dryRun) {
     await configureGitHubAuthor();
   }
 
-  if ((await run('git rev-parse --abbrev-ref HEAD')) !== MAIN_BRANCH) {
+  if (!dryRun && (await run('git rev-parse --abbrev-ref HEAD')) !== MAIN_BRANCH) {
     throw new Error(`You can run this script only from \`${MAIN_BRANCH}\` branch.`);
   }
 
-  if (!process.env.FORCE && (await getNbGitDiff({ head: null })) !== 0) {
+  if (!dryRun && !process.env.FORCE && (await getNbGitDiff({ head: null })) !== 0) {
     throw new Error('Working directory is not clean. Commit all the changes first.');
   }
 
@@ -327,22 +331,25 @@ async function prepareGitEnvironment(): Promise<void> {
     console.log('Pulling from origin...');
     await run('git fetch origin');
     await run('git fetch --tags --force');
-    await run('git pull origin $(git branch --show-current)');
+
+    if (!dryRun) {
+      await run('git pull origin $(git branch --show-current)');
+    }
   }
 }
 
 export async function createReleasePR({
   releaseType,
   dryRun,
   breaking,
+  versionsHistory,
 }: {
   releaseType?: semver.ReleaseType;
   dryRun?: boolean;
   breaking?: boolean;
+  versionsHistory?: boolean;
 }): Promise<void> {
-  if (!dryRun) {
-    await prepareGitEnvironment();
-  }
+  await prepareGitEnvironment(dryRun || versionsHistory || false);
 
   console.log('Searching for commits since last release...');
   const { validCommits, skippedCommits } = await getCommits(releaseType !== undefined);
@@ -351,6 +358,12 @@ export async function createReleasePR({
 
   await generateVersionsHistory(versions);
 
+  if (versionsHistory) {
+    console.log('Asked for a versions history refresh only, stopping here');
+
+    return;
+  }
+
   const versionChanges = getVersionChangesText(versions);
   const languages = Object.keys(versions).join(', ');
 

scripts/release/types.ts

@@ -4,8 +4,8 @@ import type { Language } from '../types.js';
 
 export type Version = {
   current: string;
-  releaseType: ReleaseType;
-  next: string;
+  releaseType?: ReleaseType;
+  next?: string;
 };
 
 export type Versions = {

scripts/release/updateAPIVersions.ts

@@ -46,6 +46,10 @@ export async function updateAPIVersions(versions: Versions, changelog: Changelog
   await updateConfigFiles(versions);
 
   for (const [lang, { current, releaseType, next }] of Object.entries(versions)) {
+    if (!next) {
+      continue;
+    }
+
     if (lang === 'dart') {
       await updateDartPackages(changelog[lang]!, next);
 

scripts/release/versionsHistory.ts

@@ -10,6 +10,20 @@ import type { Language } from '../types.js';
 import { preReleaseRegExp } from './createReleasePR.js';
 import type { Version, Versions } from './types.js';
 
+// the date of the generated api clients release
+const generatedReleaseDate = new Date('2024-08-14');
+
+// number of years of eligibility
+const eligibilityDuration = 2;
+const eligibilityEndDate = new Date(
+  generatedReleaseDate.setFullYear(generatedReleaseDate.getFullYear() + eligibilityDuration),
+);
+
+type Eligibility = {
+  status: 'eligible' | 'not eligible' | 'replaced';
+  date?: string;
+};
+
 export function isPreRelease(version: string): boolean {
   return (
     version.match(preReleaseRegExp) !== null ||
@@ -21,6 +35,24 @@ export function isPreRelease(version: string): boolean {
   );
 }
 
+function getCurrentMajor(version: string): int {
+  return parseInt(version.match(/\d+/)[0]);
+}
+
+function getEligibility(currentMajor: int, previousMajor: int, version: string, releaseDate: Date): Eligibility {
+  const versionMajor = getCurrentMajor(version);
+
+  if (versionMajor == currentMajor) {
+    return { status: 'eligible' };
+  }
+
+  if (versionMajor == previousMajor && eligibilityEndDate >= new Date()) {
+    return { status: 'replaced', date: eligibilityEndDate.toISOString().split('T')[0] };
+  }
+
+  return { status: 'not eligible' };
+}
+
 // fetches the git tags on the given `lang` repository, throws if none.
 async function getTags(lang: Language): Promise<string[]> {
   const githubToken = ensureGitHubToken();
@@ -56,8 +88,10 @@ export function generateLanguageVersionsHistory(
   lang: Language,
   version: Version,
 ): Record<string, { releaseDate: string }> {
-  const versions: Record<string, { releaseDate: string }> = {};
+  const versions: Record<string, { releaseDate: string } & Eligibility> = {};
 
+  const currentMajor = getCurrentMajor(version.current);
+  const previousMajor = currentMajor - 1 || currentMajor;
   let prevTagVersion = '';
 
   for (const tag of tags) {
@@ -73,8 +107,12 @@ export function generateLanguageVersionsHistory(
       continue;
     }
 
+    const eligibility = getEligibility(currentMajor, previousMajor, tagVersion, new Date(tagReleaseDate));
+
     versions[tagVersion] = {
       releaseDate: new Date(tagReleaseDate).toISOString().split('T')[0],
+      eligibilityDate: eligibility.date,
+      eligibilityStatus: eligibility.status,
     };
 
     prevTagVersion = tagVersion;
@@ -84,6 +122,7 @@ export function generateLanguageVersionsHistory(
   if (version?.next && !isPreRelease(version?.next) && version?.next !== prevTagVersion) {
     versions[version.next] = {
       releaseDate: new Date().toISOString().split('T')[0],
+      eligibilityStatus: 'eligible',
     };
   }