Don't error on intended functionality

src/cli/migrate/nodeVersion/index.test.ts

@@ -9,11 +9,9 @@ jest
   .spyOn(getNode22TypesVersionModule, 'getNode22TypesVersion')
   .mockReturnValue('22.9.0');
 
-jest
-  .spyOn(packageJsonChecks, 'checkServerlessVersion')
-  .mockResolvedValue(undefined);
+jest.spyOn(packageJsonChecks, 'validServerlessVersion').mockResolvedValue(true);
 
-jest.spyOn(packageJsonChecks, 'checkSkubaType').mockResolvedValue(undefined);
+jest.spyOn(packageJsonChecks, 'validSkubaType').mockResolvedValue(true);
 
 jest.mock('fs-extra', () => memfs);
 jest.mock('fast-glob', () => ({

src/cli/migrate/nodeVersion/index.ts

@@ -7,7 +7,7 @@ import { log } from '../../../utils/logging';
 import { createDestinationFileReader } from '../../configure/analysis/project';
 
 import { getNode22TypesVersion } from './getNode22TypesVersion';
-import { checkServerlessVersion, checkSkubaType } from './packageJsonChecks';
+import { validServerlessVersion, validSkubaType } from './packageJsonChecks';
 
 const DEFAULT_NODE_TYPES = '22.9.0';
 
@@ -178,11 +178,15 @@ const runSubPatch = async (
       const unPinnedContents = removeNodeShas(contents);
 
       if (patch.id === 'serverless') {
-        await checkServerlessVersion();
+        if (!(await validServerlessVersion())) {
+          return;
+        }
       }
 
       if (patch.id === 'package-json-1') {
-        await checkServerlessVersion();
+        if (!(await validServerlessVersion())) {
+          return;
+        }
         return await writePatchedContents({
           path,
           contents: unPinnedContents,
@@ -194,8 +198,9 @@ const runSubPatch = async (
         });
       }
       if (patch.id === 'tsconfig') {
-        await checkSkubaType();
-        await checkServerlessVersion();
+        if (!(await validServerlessVersion()) || !(await validSkubaType())) {
+          return;
+        }
         return await writePatchedContents({
           path,
           contents: unPinnedContents,
@@ -208,8 +213,9 @@ const runSubPatch = async (
       }
 
       if (patch.id === 'package-json-2') {
-        await checkSkubaType();
-        await checkServerlessVersion();
+        if (!(await validServerlessVersion()) || !(await validSkubaType())) {
+          return;
+        }
       }
 
       await writePatchedContents({

src/cli/migrate/nodeVersion/packageJsonChecks.test.ts

@@ -6,15 +6,15 @@ jest.mock('fs-extra');
 
 import { log } from '../../../utils/logging';
 
-import { checkServerlessVersion, checkSkubaType } from './packageJsonChecks';
+import { validServerlessVersion, validSkubaType } from './packageJsonChecks';
 
 jest.spyOn(log, 'warn');
 
 afterEach(() => {
   jest.resetAllMocks();
 });
 
-describe('checkServerlessVersion', () => {
+describe('validServerlessVersion', () => {
   it('resolves as a noop when serverless version is supported', async () => {
     jest.mocked(findUp).mockResolvedValueOnce('package.json');
     jest
@@ -27,9 +27,9 @@ describe('checkServerlessVersion', () => {
           },
         }) as never,
       );
-    await expect(checkServerlessVersion()).resolves.toBeUndefined();
+    await expect(validServerlessVersion()).resolves.toBe(true);
   });
-  it('throws when the serverless version is below 4', async () => {
+  it('should return false when the serverless version is below 4', async () => {
     jest.mocked(findUp).mockResolvedValueOnce('package.json');
     jest
       .spyOn(fs, 'readFile')
@@ -41,28 +41,26 @@ describe('checkServerlessVersion', () => {
           },
         }) as never,
       );
-    await expect(checkServerlessVersion()).rejects.toThrow(
-      'Serverless version not supported, please upgrade to 4.x',
-    );
+    await expect(validServerlessVersion()).resolves.toBe(false);
   });
-  it('resolves as a noop when serverless version is not found', async () => {
+  it('should return true when serverless version is not found', async () => {
     jest.mocked(findUp).mockResolvedValueOnce('package.json');
     jest
       .spyOn(fs, 'readFile')
       .mockImplementation()
       .mockReturnValue(JSON.stringify({}) as never);
-    await expect(checkServerlessVersion()).resolves.toBeUndefined();
+    await expect(validServerlessVersion()).resolves.toBe(true);
   });
   it('throws when no package.json is found', async () => {
     jest.mocked(findUp).mockResolvedValueOnce(undefined);
-    await expect(checkServerlessVersion()).rejects.toThrow(
+    await expect(validServerlessVersion()).rejects.toThrow(
       'package.json not found',
     );
   });
 });
 
-describe('checkSkubaType', () => {
-  it('should return undefined when skuba type is not "package"', async () => {
+describe('validSkubaType', () => {
+  it('should return true when skuba type is not "package"', async () => {
     jest.mocked(findUp).mockResolvedValueOnce('package.json');
     jest
       .spyOn(fs, 'readFile')
@@ -74,9 +72,9 @@ describe('checkSkubaType', () => {
           },
         }) as never,
       );
-    await expect(checkSkubaType()).resolves.toBeUndefined();
+    await expect(validSkubaType()).resolves.toBe(true);
   });
-  it('should throw when skuba type is "package"', async () => {
+  it('should return false when skuba type is "package"', async () => {
     jest.mocked(findUp).mockResolvedValueOnce('package.json');
     jest
       .spyOn(fs, 'readFile')
@@ -88,16 +86,14 @@ describe('checkSkubaType', () => {
           },
         }) as never,
       );
-    await expect(checkSkubaType()).rejects.toThrow(
-      'Skuba type package is not supported, packages should be updated manually to ensure major runtime depreciations are intended',
-    );
+    await expect(validSkubaType()).resolves.toBe(false);
   });
-  it('should return undefined when skuba type is not found', async () => {
+  it('should return true when skuba type is not found', async () => {
     jest.mocked(findUp).mockResolvedValueOnce('package.json');
     jest
       .spyOn(fs, 'readFile')
       .mockImplementation()
       .mockReturnValue(JSON.stringify({}) as never);
-    await expect(checkSkubaType()).resolves.toBeUndefined();
+    await expect(validSkubaType()).resolves.toBe(true);
   });
 });

src/cli/migrate/nodeVersion/packageJsonChecks.ts

@@ -1,6 +1,8 @@
 import findUp from 'find-up';
 import fs from 'fs-extra';
 
+import { log } from '../../../utils/logging';
+
 const getParentPackageJson = async () => {
   const packageJsonPath = await findUp('package.json', { cwd: process.cwd() });
   if (!packageJsonPath) {
@@ -16,7 +18,7 @@ const isTypeError = (error: unknown): error is TypeError =>
 const isSyntaxError = (error: unknown): error is SyntaxError =>
   error instanceof SyntaxError && error.message.includes('Unexpected token');
 
-export const checkServerlessVersion = async () => {
+export const validServerlessVersion = async (): Promise<boolean> => {
   const packageJson = await getParentPackageJson();
 
   try {
@@ -26,23 +28,25 @@ export const checkServerlessVersion = async () => {
       }
     ).devDependencies.serverless;
     if (!serverlessVersion) {
-      return;
+      return true;
     }
 
     if (!serverlessVersion.startsWith('4')) {
-      throw new Error(
-        'Serverless version not supported, please upgrade to 4.x',
+      log.warn(
+        'Serverless version not supported, please upgrade to 4.x to automatically update serverless files',
       );
+      return false;
     }
   } catch (error) {
     if (isTypeError(error) || isSyntaxError(error)) {
-      return;
+      return true;
     }
     throw error;
   }
+  return true;
 };
 
-export const checkSkubaType = async () => {
+export const validSkubaType = async () => {
   const packageJson = await getParentPackageJson();
 
   try {
@@ -52,18 +56,20 @@ export const checkSkubaType = async () => {
       }
     ).skuba.type;
     if (!type) {
-      return;
+      return true;
     }
 
     if (type === 'package') {
-      throw new Error(
+      log.warn(
         'Skuba type package is not supported, packages should be updated manually to ensure major runtime depreciations are intended',
       );
+      return false;
     }
   } catch (error) {
     if (isTypeError(error) || isSyntaxError(error)) {
-      return;
+      return true;
     }
     throw error;
   }
+  return true;
 };