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/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 @@
 
  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,
@@ -37,7 +38,7 @@
  );
  const log = vi.spyOn(loggerMod, 'log');
  await expect(checkForAndDisplayUpdatesMod.checkForAndDisplayUpdates()).resolves.not.toThrow();
  expect(log).toHaveBeenCalledWith('\n Unable to fetch latest fuels version. Skipping...\n');
  });
 
  test('should log a warning if the version is outdated', async () => {
@@ -63,6 +64,6 @@
  );
  const log = vi.spyOn(loggerMod, 'log');
  await expect(checkForAndDisplayUpdatesMod.checkForAndDisplayUpdates()).resolves.not.toThrow();
  expect(log).toHaveBeenCalledWith('\n Unable to fetch latest fuels version. Skipping...\n');
  });
 });

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,42 @@
+import * as cacheMod from './fuelsVersionCache';
+import { getLatestFuelsVersion } from './getLatestFuelsVersion';
+
+/**
+ * @group node
+ */
+describe('getLatestFuelsVersion', () => {
+ 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);
 };