refactor: make versions package usable locally (#850)

Author: arboleya

.changeset/quick-fireants-sleep.md

@@ -0,0 +1,5 @@
+---
+"@fuel-ts/versions": patch
+---
+
+Refactoring `versions` packages so that it can be used locally, providing accurate versions for all relevant parts of the stack

package.json

@@ -45,8 +45,8 @@
     "@changesets/changelog-github": "^0.4.7",
     "@changesets/cli": "^2.25.0",
     "@ethersproject/bytes": "^5.7.0",
-    "@jest/types": "29.4.3",
-    "@types/jest": "^29.2.3",
+    "@jest/types": "^29.5.0",
+    "@types/jest": "^29.5.0",
     "@types/node": "^14.18.32",
     "@types/node-fetch": "^2.6.2",
     "@types/shelljs": "^0.8.11",
@@ -70,7 +70,7 @@
     "ethers": "^5.7.2",
     "forc-bin": "workspace:*",
     "husky": "^8.0.3",
-    "jest": "^29.3.1",
+    "jest": "^29.5.0",
     "jest-text-transformer": "^1.0.4",
     "markdownlint": "^0.23.1",
     "markdownlint-cli": "^0.27.1",

packages/abi-typegen/src/templates/common/common.test.ts

@@ -5,14 +5,22 @@ import { renderCommonTemplate } from './common';
 describe('templates/common', () => {
   test('should render common template', () => {
     // mocking
-    const { restore } = mockVersions();
+    const { versions, restore } = mockVersions();
 
     // executing
-    const expectedVersion = /(Fuels|Forc|Fuel-Core) version: 0.0.0/;
+    const rendered = renderCommonTemplate();
 
     // validating
     restore();
 
-    expect(renderCommonTemplate()).toMatch(expectedVersion);
+    const { FORC, FUELS, FUEL_CORE } = versions;
+
+    const expectedFuelsVersion = new RegExp(`Fuels version: ${FUELS}`);
+    const expectedForcVersion = new RegExp(`Forc version: ${FORC}`);
+    const expectedFuelCoreVersion = new RegExp(`Fuel-Core version: ${FUEL_CORE}`);
+
+    expect(rendered).toMatch(expectedFuelsVersion);
+    expect(rendered).toMatch(expectedForcVersion);
+    expect(rendered).toMatch(expectedFuelCoreVersion);
   });
 });

packages/abi-typegen/test/utils/mockVersions.ts

@@ -1,4 +1,4 @@
-import { versions } from '@fuel-ts/versions';
+import * as versionsMod from '@fuel-ts/versions';
 
 export function mockVersions(
   values: {
@@ -11,14 +11,12 @@ export function mockVersions(
     FUEL_CORE: '33.33.33',
   }
 ) {
-  const original = { ...versions };
-
-  Object.assign(versions, values);
+  const mock = jest.replaceProperty(versionsMod, 'versions', values);
 
   return {
     versions: values,
     restore() {
-      Object.assign(versions, original);
+      mock.restore();
     },
   };
 }

packages/versions/package.json

@@ -57,6 +57,7 @@
     "@types/semver": "^7.3.13"
   },
   "scripts": {
-    "build": "tsup --dts --env.BUILD_VERSION $BUILD_VERSION --env.FORC_VERSION $FORC_VERSION --env.FUEL_CORE_VERSION $FUEL_CORE_VERSION"
+    "prebuild": "ts-node ./scripts/rewriteVersions.ts",
+    "build": "tsup --dts"
   }
 }

packages/versions/scripts/rewriteVersions.test.ts

@@ -0,0 +1,75 @@
+import { readVersions, readVersionsFromEnv, readVersionsFromFiles } from './rewriteVersions';
+
+describe('getSupportedVersions.js', () => {
+  function modifyEnv() {
+    const envBackup = { ...process.env };
+
+    const BUILD_VERSION = '9.9.9';
+    const FORC_VERSION = '8.8.8';
+    const FUEL_CORE_VERSION = '7.7.7';
+
+    process.env.BUILD_VERSION = BUILD_VERSION;
+    process.env.FORC_VERSION = FORC_VERSION;
+    process.env.FUEL_CORE_VERSION = FUEL_CORE_VERSION;
+
+    return {
+      BUILD_VERSION,
+      FORC_VERSION,
+      FUEL_CORE_VERSION,
+      restoreEnv() {
+        process.env = envBackup;
+      },
+    };
+  }
+
+  test('should read versions from files', async () => {
+    const versionsFromFiles = readVersionsFromFiles();
+
+    expect(versionsFromFiles.FORC).toBeTruthy();
+    expect(versionsFromFiles.FUEL_CORE).toBeTruthy();
+    expect(versionsFromFiles.FUELS).toBeTruthy();
+  });
+
+  test('should read versions from env', async () => {
+    // mocking
+    const { BUILD_VERSION, FORC_VERSION, FUEL_CORE_VERSION, restoreEnv } = modifyEnv();
+
+    // executing
+    const versions = readVersionsFromEnv();
+
+    // restoring
+    restoreEnv();
+
+    // validating
+    expect(versions.FORC).toEqual(FORC_VERSION);
+    expect(versions.FUEL_CORE).toEqual(FUEL_CORE_VERSION);
+    expect(versions.FUELS).toEqual(BUILD_VERSION);
+  });
+
+  test('should prioritize versions from env', async () => {
+    // mocking
+    const { BUILD_VERSION, FORC_VERSION, FUEL_CORE_VERSION, restoreEnv } = modifyEnv();
+
+    // executing
+    const versions = readVersions();
+
+    // restoring
+    restoreEnv();
+
+    // validating
+    expect(versions.FORC).toEqual(FORC_VERSION);
+    expect(versions.FUEL_CORE).toEqual(FUEL_CORE_VERSION);
+    expect(versions.FUELS).toEqual(BUILD_VERSION);
+  });
+
+  test('should fallback to versions from files', async () => {
+    // executing
+    const versions = readVersions();
+    const versionsFromFiles = readVersionsFromFiles();
+
+    // validating
+    expect(versions.FORC).toEqual(versionsFromFiles.FORC);
+    expect(versions.FUEL_CORE).toEqual(versionsFromFiles.FUEL_CORE);
+    expect(versions.FUELS).toEqual(versionsFromFiles.FUELS);
+  });
+});

packages/versions/scripts/rewriteVersions.ts

@@ -0,0 +1,66 @@
+import { readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+
+export const readVersionsFromFiles = () => {
+  const rootDir = join(__dirname, '../../..');
+  const packagesDir = join(rootDir, 'packages');
+  const servicesDir = join(rootDir, 'services');
+
+  // forc-bin
+  const forcPath = join(packagesDir, 'forc-bin', 'package.json');
+  const forcPkgJson = JSON.parse(readFileSync(forcPath, 'utf8'));
+
+  // fuel-core
+  const dockerFilePath = join(servicesDir, 'fuel-core', 'Dockerfile');
+  const dockerFileContents = readFileSync(dockerFilePath, 'utf8');
+  const regexFuelcore = /FROM ghcr\.io\/fuellabs\/fuel-core:v(\d+\.\d+\.\d+)/;
+  const match = dockerFileContents.match(regexFuelcore);
+
+  // fuels
+  const fuelsPath = join(packagesDir, 'fuels', 'package.json');
+  const fuelsPkgJson = JSON.parse(readFileSync(fuelsPath, 'utf8'));
+
+  const versions = {
+    FORC: forcPkgJson.config.forcVersion,
+    FUELS: fuelsPkgJson.version,
+    FUEL_CORE: match?.[1],
+  };
+
+  return versions;
+};
+
+export const readVersionsFromEnv = () => {
+  const versions = {
+    FORC: process.env.FORC_VERSION,
+    FUEL_CORE: process.env.FUEL_CORE_VERSION,
+    FUELS: process.env.BUILD_VERSION,
+  };
+  return versions;
+};
+
+export const readVersions = () => {
+  const fromFiles = readVersionsFromFiles();
+  const fromEnv = readVersionsFromEnv();
+
+  const FUELS = fromEnv.FUELS || fromFiles.FUELS;
+  const FORC = fromEnv.FORC || fromFiles.FORC;
+  const FUEL_CORE = fromEnv.FUEL_CORE || fromFiles.FUEL_CORE;
+
+  return { FUELS, FORC, FUEL_CORE };
+};
+
+export const rewriteVersions = () => {
+  const { FUELS, FORC, FUEL_CORE } = readVersions();
+
+  const filepath = join(__dirname, '..', 'src', 'lib', 'getSupportedVersions.ts');
+
+  let contents = readFileSync(filepath, 'utf8');
+
+  contents = contents.replace(/FUELS: '[\d.]+'/, `FUELS: '${FUELS}'`);
+  contents = contents.replace(/FORC: '[\d.]+'/, `FORC: '${FORC}'`);
+  contents = contents.replace(/FUEL_CORE: '[\d.]+'/, `FUEL_CORE: '${FUEL_CORE}'`);
+
+  writeFileSync(filepath, contents);
+};
+
+rewriteVersions();

packages/versions/src/index.ts

@@ -1,20 +1,38 @@
 /*
-  Variables:
+  1) Variables
+  ------------
     `FUELS` — comes from `/packages/fuels/package.json`
     `FUEL_CORE` — comes from `/services/fuel-core/Dockerfile`
     `FORC` — comes from `/packages/forc-bin/package.json`
 
-  The CI release routine reads the aforementioned files,
-  and set all the variables prior to building the packages.
+  3) Pre Build
+  ------------
+    There's a `prebuild` script in:
+     - packages/versions/package.json
 
-  Take a look at the /.github/workflows/release` file.
+    Before build, it will call this file:
+      - packages/versions/scripts/replaceVersions.ts
 
-  The TSUP build then replaces all `process.env.<VAR_NAME>`
-  entries bellow with their respective values from the env.
+    Which will replace static versions at:
+      - packages/versions/src/lib/getSupportedVersions.ts
 
-  If no env variables are set, the expression `!0` seems to be
-  used by TSUP, which then results to `true`. For this reason,
-  we check for it and use default values instead.
+    If no env variables are set, it uses the current versions
+    from the original locations mentioned in the 1st step.
+
+  3)  CI
+  ------------
+    As part of the CI release (1) routine, the changes made
+    to the versions package by the `prebuild` routine will
+    be committed by the same script (2) that handles the
+    docs versioning.
+
+      - (1) <repoRoot>/.github/workflows/release.yaml
+      - (2) <repoRoot>/changeset-version-with-docs.ts
+
+  4) Build
+  ------------
+    By the time we get to the `build` step, everything is in
+    place already and ready to be built and released.
 */
 
 import { getSupportedVersions } from './lib/getSupportedVersions';

packages/versions/src/lib/getSupportedVersions.test.ts

@@ -1,34 +1,14 @@
-import { getSupportedVersions, thisVersionOrDefault } from './getSupportedVersions';
+import { readVersionsFromFiles } from '../../scripts/rewriteVersions';
+
+import { getSupportedVersions } from './getSupportedVersions';
 
 describe('getSupportedVersions.js', () => {
   test('should return received version of default', async () => {
-    expect(thisVersionOrDefault()).toEqual('0.0.0');
-    expect(thisVersionOrDefault('true')).toEqual('0.0.0');
-    expect(thisVersionOrDefault(undefined)).toEqual('0.0.0');
-    expect(thisVersionOrDefault('1.1.1')).toEqual('1.1.1');
-  });
-
-  test('should get versions just fine', async () => {
-    // mocking
-    const envBackup = { ...process.env };
-
-    const BUILD_VERSION = '9.9.9';
-    const FORC_VERSION = '8.8.8';
-    const FUEL_CORE_VERSION = '7.7.7';
-
-    process.env.BUILD_VERSION = BUILD_VERSION;
-    process.env.FORC_VERSION = FORC_VERSION;
-    process.env.FUEL_CORE_VERSION = FUEL_CORE_VERSION;
-
-    // executing
-    const env = getSupportedVersions();
-
-    // restoring
-    process.env = envBackup;
+    const versions = getSupportedVersions();
+    const versionsFromFiles = readVersionsFromFiles();
 
-    // validating
-    expect(env.FUELS).toEqual(BUILD_VERSION);
-    expect(env.FORC).toEqual(FORC_VERSION);
-    expect(env.FUEL_CORE).toEqual(FUEL_CORE_VERSION);
+    expect(versions.FORC).toEqual(versionsFromFiles.FORC);
+    expect(versions.FUEL_CORE).toEqual(versionsFromFiles.FUEL_CORE);
+    expect(versions.FUELS).toEqual(versionsFromFiles.FUELS);
   });
 });

packages/versions/src/lib/getSupportedVersions.ts

@@ -1,17 +1,7 @@
-export function thisVersionOrDefault(version?: string | boolean) {
-  if (version !== undefined) {
-    const versionStr = version.toString();
-    if (versionStr !== 'true') {
-      return versionStr;
-    }
-  }
-  return '0.0.0';
-}
-
 export function getSupportedVersions() {
   return {
-    FUELS: thisVersionOrDefault(process.env.BUILD_VERSION),
-    FUEL_CORE: thisVersionOrDefault(process.env.FUEL_CORE_VERSION),
-    FORC: thisVersionOrDefault(process.env.FORC_VERSION),
+    FORC: '0.35.3',
+    FUEL_CORE: '0.17.3',
+    FUELS: '0.35.0',
   };
 }