feat: cache latest fuels version

.changeset/kind-chairs-move.md

@@ -0,0 +1,5 @@
+---
+"fuels": patch
+---
+
+feat: cache latest `fuels` version

packages/fuels/src/cli.test.ts

@@ -2,6 +2,7 @@ import { Command } from 'commander';
 
 import * as cliMod from './cli';
 import { Commands } from './cli/types';
+import * as checkForUpdatesMod from './cli/utils/checkForAndDisplayUpdates';
 import * as loggingMod from './cli/utils/logger';
 import { run } from './run';
 
@@ -77,6 +78,9 @@ describe('cli.js', () => {
       .mockReturnValue(Promise.resolve(command));
 
     const configureCli = vi.spyOn(cliMod, 'configureCli').mockImplementation(() => new Command());
+    vi.spyOn(checkForUpdatesMod, 'checkForAndDisplayUpdates').mockImplementation(() =>
+      Promise.resolve()
+    );
 
     await run([]);
 

packages/fuels/src/cli/config/loadConfig.test.ts

@@ -1,6 +1,7 @@
 import { readFileSync } from 'fs';
 import { resolve } from 'path';
 
+import { mockCheckForUpdates } from '../../../test/utils/mockCheckForUpdates';
 import {
   runInit,
   bootstrapProject,
@@ -19,6 +20,10 @@ import { loadConfig } from './loadConfig';
 describe('loadConfig', () => {
   const paths = bootstrapProject(__filename);
 
+  beforeEach(() => {
+    mockCheckForUpdates();
+  });
+
   afterEach(() => {
     resetConfigAndMocks(paths.fuelsConfigPath);
   });

packages/fuels/src/cli/utils/checkForAndDisplayUpdates.test.ts

@@ -1,6 +1,7 @@
 import * as versionsMod from '@fuel-ts/versions';
 
 import * as checkForAndDisplayUpdatesMod from './checkForAndDisplayUpdates';
+import * as getLatestFuelsVersionMod from './getLatestFuelsVersion';
 import * as loggerMod from './logger';
 
 /**
@@ -17,7 +18,7 @@ describe('checkForAndDisplayUpdates', () => {
 
   const mockDeps = (params: { latestVersion: string; userVersion: string }) => {
     const { latestVersion, userVersion } = params;
-    vi.spyOn(Promise, 'race').mockReturnValue(Promise.resolve(latestVersion));
+    vi.spyOn(getLatestFuelsVersionMod, 'getLatestFuelsVersion').mockResolvedValue(latestVersion);
 
     vi.spyOn(versionsMod, 'versions', 'get').mockReturnValue({
       FUELS: userVersion,

packages/fuels/src/cli/utils/checkForAndDisplayUpdates.ts

@@ -1,23 +1,13 @@
 import { versions, gt, eq } from '@fuel-ts/versions';
 
+import { getLatestFuelsVersion } from './getLatestFuelsVersion';
 import { warn, log } from './logger';
 
-export const getLatestFuelsVersion = async () => {
-  const response = await fetch('https://registry.npmjs.org/fuels/latest');
-  const data = await response.json();
-  return data.version as string;
-};
-
 export const checkForAndDisplayUpdates = async () => {
   try {
     const { FUELS: userFuelsVersion } = versions;
 
-    const latestFuelsVersion = await Promise.race<string | undefined>([
-      new Promise((resolve) => {
-        setTimeout(resolve, 3000);
-      }),
-      getLatestFuelsVersion(),
-    ]);
+    const latestFuelsVersion = await getLatestFuelsVersion();
 
     if (!latestFuelsVersion) {
       log(`\n Unable to fetch latest fuels version. Skipping...\n`);

packages/fuels/src/cli/utils/fuelsVersionCache.ts

@@ -0,0 +1,23 @@
+import fs from 'fs';
+import path from 'path';
+
+export const FUELS_VERSION_CACHE_FILE = path.join(__dirname, 'FUELS_VERSION');
+
+export type FuelsVersionCache = string;
+
+export const saveToCache = (cache: FuelsVersionCache) => {
+  fs.writeFileSync(FUELS_VERSION_CACHE_FILE, cache, 'utf-8');
+};
+
+export const FUELS_VERSION_CACHE_TTL = 6 * 60 * 60 * 1000; // 6 hours in milliseconds
+
+export const checkAndLoadCache = (): FuelsVersionCache | null => {
+  if (fs.existsSync(FUELS_VERSION_CACHE_FILE)) {
+    const cachedVersion = fs.readFileSync(FUELS_VERSION_CACHE_FILE, 'utf-8');
+    const { mtimeMs: cacheTimestamp } = fs.statSync(FUELS_VERSION_CACHE_FILE);
+    if (cachedVersion && Date.now() - cacheTimestamp < FUELS_VERSION_CACHE_TTL) {
+      return cachedVersion;
+    }
+  }
+  return null;
+};

packages/fuels/src/cli/utils/getLatestFuelsVersion.test.ts

@@ -0,0 +1,50 @@
+import * as cacheMod from './fuelsVersionCache';
+import { getLatestFuelsVersion } from './getLatestFuelsVersion';
+
+/**
+ * @group node
+ */
+describe('getLatestFuelsVersion', () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('should fail if fetch fails', async () => {
+    vi.spyOn(global, 'fetch').mockImplementation(() =>
+      Promise.reject(new Error('Failed to fetch'))
+    );
+    await expect(getLatestFuelsVersion()).rejects.toThrowError('Failed to fetch');
+  });
+
+  it('should throw if fetch times out', async () => {
+    vi.spyOn(global, 'fetch').mockImplementation(
+      () =>
+        new Promise((resolve) => {
+          setTimeout(resolve, 5000);
+        })
+    );
+    await expect(getLatestFuelsVersion()).rejects.toThrow();
+  });
+
+  it('should return cached version if it exists', async () => {
+    const cachedVersion = '1.0.0';
+    vi.spyOn(cacheMod, 'checkAndLoadCache').mockReturnValue(cachedVersion);
+    const result = await getLatestFuelsVersion();
+    expect(result).toEqual('1.0.0');
+  });
+
+  it('should fetch if there is no cache or the cache is expired', async () => {
+    const mockResponse = new Response(JSON.stringify({ version: '1.0.0' }));
+    const fetchSpy = vi.spyOn(global, 'fetch').mockReturnValue(Promise.resolve(mockResponse));
+    const saveCacheSpy = vi.spyOn(cacheMod, 'saveToCache').mockImplementation(() => {});
+    vi.spyOn(cacheMod, 'checkAndLoadCache').mockReturnValue(null);
+    const version = await getLatestFuelsVersion();
+    expect(fetchSpy).toHaveBeenCalled();
+    expect(version).toEqual('1.0.0');
+    expect(saveCacheSpy).toHaveBeenCalledWith('1.0.0');
+  });
+});

packages/fuels/src/cli/utils/getLatestFuelsVersion.ts

@@ -0,0 +1,25 @@
+import { checkAndLoadCache, saveToCache } from './fuelsVersionCache';
+
+export const getLatestFuelsVersion = async (): Promise<string | undefined> => {
+  const cachedVersion = checkAndLoadCache();
+  if (cachedVersion) {
+    return cachedVersion;
+  }
+
+  const data: { version: string } | null = await Promise.race([
+    new Promise((resolve) => {
+      setTimeout(() => resolve(null), 3000);
+    }),
+    fetch('https://registry.npmjs.org/fuels/latest').then((response) => response.json()),
+  ]);
+
+  if (!data) {
+    throw new Error('Failed to fetch latest fuels version.');
+  }
+
+  const version = data.version as string;
+
+  saveToCache(version);
+
+  return version;
+};

packages/fuels/src/run.ts

@@ -3,6 +3,7 @@ import { checkForAndDisplayUpdates } from './cli/utils/checkForAndDisplayUpdates
 import { error } from './cli/utils/logger';
 
 export const run = async (argv: string[]) => {
+  await checkForAndDisplayUpdates().catch(error);
   const program = configureCli();
-  return Promise.all([await checkForAndDisplayUpdates().catch(error), program.parseAsync(argv)]);
+  return program.parseAsync(argv);
 };

packages/fuels/test/features/build.test.ts

@@ -3,6 +3,7 @@ import { join } from 'path';
 
 import * as deployMod from '../../src/cli/commands/deploy/index';
 import { mockStartFuelCore } from '../utils/mockAutoStartFuelCore';
+import { mockCheckForUpdates } from '../utils/mockCheckForUpdates';
 import {
   bootstrapProject,
   resetConfigAndMocks,
@@ -17,6 +18,10 @@ import {
 describe('build', { timeout: 180000 }, () => {
   const paths = bootstrapProject(__filename);
 
+  beforeEach(() => {
+    mockCheckForUpdates();
+  });
+
   afterEach(() => {
     resetConfigAndMocks(paths.fuelsConfigPath);
   });

packages/fuels/test/features/deploy.test.ts

@@ -5,6 +5,7 @@ import { existsSync, readFileSync, writeFileSync } from 'fs';
 import { join } from 'path';
 
 import { launchTestNode } from '../../src/test-utils';
+import { mockCheckForUpdates } from '../utils/mockCheckForUpdates';
 import { resetDiskAndMocks } from '../utils/resetDiskAndMocks';
 import {
   bootstrapProject,
@@ -24,6 +25,7 @@ describe('deploy', { timeout: 180000 }, () => {
     resetConfigAndMocks(paths.fuelsConfigPath);
     resetDiskAndMocks(paths.root);
     paths = bootstrapProject(__filename);
+    mockCheckForUpdates();
   });
 
   afterEach(() => {

packages/fuels/test/features/dev.test.ts

@@ -3,6 +3,7 @@ import * as chokidar from 'chokidar';
 import * as buildMod from '../../src/cli/commands/build/index';
 import * as deployMod from '../../src/cli/commands/deploy/index';
 import { mockStartFuelCore } from '../utils/mockAutoStartFuelCore';
+import { mockCheckForUpdates } from '../utils/mockCheckForUpdates';
 import { mockLogger } from '../utils/mockLogger';
 import { resetDiskAndMocks } from '../utils/resetDiskAndMocks';
 import { runInit, runDev, bootstrapProject, resetConfigAndMocks } from '../utils/runCommands';
@@ -21,6 +22,10 @@ vi.mock('chokidar', async () => {
 describe('dev', () => {
   const paths = bootstrapProject(__filename);
 
+  beforeEach(() => {
+    mockCheckForUpdates();
+  });
+
   afterEach(() => {
     resetConfigAndMocks(paths.fuelsConfigPath);
   });

packages/fuels/test/features/init.test.ts

@@ -2,6 +2,7 @@ import chalk from 'chalk';
 import { existsSync, readFileSync } from 'fs';
 
 import { Commands } from '../../src';
+import { mockCheckForUpdates } from '../utils/mockCheckForUpdates';
 import { mockLogger } from '../utils/mockLogger';
 import {
   bootstrapProject,
@@ -19,6 +20,7 @@ describe('init', () => {
 
   beforeEach(() => {
     mockLogger();
+    mockCheckForUpdates();
   });
 
   afterEach(() => {

packages/fuels/test/utils/mockCheckForUpdates.ts

@@ -0,0 +1,7 @@
+import * as checkForUpdatesMod from '../../src/cli/utils/checkForAndDisplayUpdates';
+
+export const mockCheckForUpdates = () => {
+  vi.spyOn(checkForUpdatesMod, 'checkForAndDisplayUpdates').mockImplementation(() =>
+    Promise.resolve()
+  );
+};