@squiz/job-runner-lib 2.8.0 → 2.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@squiz/job-runner-lib",
-  "version": "2.8.0",
+  "version": "2.10.0",
   "description": "",
   "main": "lib/index.js",
   "private": false,

package/src/domains/job/constants/QueueBacklog.constants.ts

@@ -0,0 +1,12 @@
+/*!
+ * @license
+ * Copyright Squiz Australia Pty Ltd. All Rights Reserved.
+ */
+
+/**
+ * Backlog guard defaults. A job's `begin` is rejected with 422 once it has more than
+ * DEFAULT_MAX_QUEUED_EXECUTIONS queued AND its oldest queued execution is older than
+ * DEFAULT_MAX_QUEUED_AGE_HOURS. Both conditions are required (large AND stale).
+ */
+export const DEFAULT_MAX_QUEUED_EXECUTIONS = 500;
+export const DEFAULT_MAX_QUEUED_AGE_HOURS = 2;

package/src/domains/job/constants/RuntimeImage.constants.spec.ts

@@ -0,0 +1,26 @@
+/*!
+ * @license
+ * Copyright Squiz Australia Pty Ltd. All Rights Reserved.
+ */
+
+import { RECOMMENDED_RUNTIME_IMAGE, getRuntimeImageOrDefault } from './RuntimeImage.constants';
+
+describe('RuntimeImage.constants', () => {
+  describe('getRuntimeImageOrDefault', () => {
+    it('returns the recommended runtime image when image is undefined', () => {
+      expect(getRuntimeImageOrDefault(undefined)).toEqual(RECOMMENDED_RUNTIME_IMAGE);
+    });
+
+    it('returns the recommended runtime image when image is null', () => {
+      expect(getRuntimeImageOrDefault(null)).toEqual(RECOMMENDED_RUNTIME_IMAGE);
+    });
+
+    it('remaps deprecated node:20 to the recommended runtime image', () => {
+      expect(getRuntimeImageOrDefault('node:20')).toEqual(RECOMMENDED_RUNTIME_IMAGE);
+    });
+
+    it('returns node:24 unchanged', () => {
+      expect(getRuntimeImageOrDefault('node:24')).toEqual('node:24');
+    });
+  });
+});

package/src/domains/job/constants/RuntimeImage.constants.ts

@@ -3,24 +3,21 @@
  * Copyright Squiz Australia Pty Ltd. All Rights Reserved.
  */
 
-export const SUPPORTED_RUNTIME_IMAGES = ['node:20', 'node:24'] as const;
-
-// Default for jobs that pre-date runtime image support.
-export const LEGACY_RUNTIME_IMAGE = 'node:20';
+export const SUPPORTED_RUNTIME_IMAGES = ['node:24'] as const;
 
 export const RECOMMENDED_RUNTIME_IMAGE = 'node:24';
 
-// Still runnable but rejected on new uploads.
-export const DEPRECATED_RUNTIME_IMAGES: readonly string[] = [];
+// Stored on old job records; remapped to RECOMMENDED_RUNTIME_IMAGE at read/execute time. Rejected on new uploads.
+export const DEPRECATED_RUNTIME_IMAGES: readonly string[] = ['node:20'];
+
+export const isDeprecatedRuntimeImage = (image: string): boolean => DEPRECATED_RUNTIME_IMAGES.includes(image);
 
 export const getRuntimeImageOrDefault = (image: string | null | undefined): string =>
-  image === null || image === undefined ? LEGACY_RUNTIME_IMAGE : image;
+  image === null || image === undefined || isDeprecatedRuntimeImage(image) ? RECOMMENDED_RUNTIME_IMAGE : image;
 
 export const isSupportedRuntimeImage = (image: string): boolean =>
   (SUPPORTED_RUNTIME_IMAGES as readonly string[]).includes(image);
 
-export const isDeprecatedRuntimeImage = (image: string): boolean => DEPRECATED_RUNTIME_IMAGES.includes(image);
-
 export const getRuntimeImagesMetadata = () => ({
   supportedRuntimeImages: [...SUPPORTED_RUNTIME_IMAGES],
   deprecatedRuntimeImages: [...DEPRECATED_RUNTIME_IMAGES],

package/src/domains/job/index.ts

@@ -3,6 +3,7 @@ export * from './core/pagination';
 
 export * from './constants/InjectTokens';
 export * from './constants/JobExecutionStatus.constants';
+export * from './constants/QueueBacklog.constants';
 export * from './constants/Repository.constants';
 export * from './constants/RetryConfig.constants';
 export * from './constants/RuntimeImage.constants';

package/src/domains/job/manifest/mocks/JobManifest.mock.ts

@@ -5,7 +5,7 @@
 
 import { faker } from '@faker-js/faker/locale/en';
 import { ENTITY_TYPES } from '../../constants/Repository.constants';
-import { LEGACY_RUNTIME_IMAGE } from '../../constants/RuntimeImage.constants';
+import { RECOMMENDED_RUNTIME_IMAGE } from '../../constants/RuntimeImage.constants';
 import { JobManifest } from '../JobManifestTypes';
 
 export const createMockJobManifest = (partialRecord: Partial<JobManifest> = {}): JobManifest => {
@@ -25,7 +25,7 @@ export const createMockJobManifest = (partialRecord: Partial<JobManifest> = {}):
     name: faker.lorem.word(),
     version,
     timeoutSeconds: faker.number.int({ max: 28800, min: 5 }),
-    image: LEGACY_RUNTIME_IMAGE,
+    image: RECOMMENDED_RUNTIME_IMAGE,
     autoRetry: false,
     type: ENTITY_TYPES.manifest,
     ...partialRecord,

package/src/domains/job/manifest/mocks/JobManifestDto.mock.ts

@@ -5,7 +5,7 @@
 
 import { faker } from '@faker-js/faker/locale/en';
 import { ENTITY_TYPES } from '../../constants/Repository.constants';
-import { LEGACY_RUNTIME_IMAGE } from '../../constants/RuntimeImage.constants';
+import { RECOMMENDED_RUNTIME_IMAGE } from '../../constants/RuntimeImage.constants';
 import { JobManifestDto, JobManifestRecord } from '../JobManifestTypes';
 
 export const createMockJobManifestDto = (partialRecord: Partial<JobManifestRecord> = {}): JobManifestDto => {
@@ -40,7 +40,7 @@ export const createMockJobManifestDto = (partialRecord: Partial<JobManifestRecor
       N: (partialRecord.timeoutSeconds ?? faker.number.int({ max: 28800, min: 5 })).toString(),
     },
     image: {
-      S: partialRecord.image ?? LEGACY_RUNTIME_IMAGE,
+      S: partialRecord.image ?? RECOMMENDED_RUNTIME_IMAGE,
     },
     autoRetry: {
       BOOL: partialRecord.autoRetry ?? false,

package/src/domains/job/manifest/mocks/JobManifestRecord.mock.ts

@@ -5,7 +5,7 @@
 
 import { faker } from '@faker-js/faker/locale/en';
 import { ENTITY_TYPES } from '../../constants/Repository.constants';
-import { LEGACY_RUNTIME_IMAGE } from '../../constants/RuntimeImage.constants';
+import { RECOMMENDED_RUNTIME_IMAGE } from '../../constants/RuntimeImage.constants';
 import { JobManifestRecord } from '../JobManifestTypes';
 
 export const createMockJobManifestRecord = (partialRecord: Partial<JobManifestRecord> = {}): JobManifestRecord => {
@@ -29,7 +29,7 @@ export const createMockJobManifestRecord = (partialRecord: Partial<JobManifestRe
     name,
     version,
     timeoutSeconds: faker.number.int({ max: 28800, min: 5 }),
-    image: LEGACY_RUNTIME_IMAGE,
+    image: RECOMMENDED_RUNTIME_IMAGE,
     autoRetry: false,
     ...partialRecord,
   };

package/src/domains/job/manifest/mocks/JobManifestRequest.mock.ts

@@ -4,7 +4,7 @@
  */
 
 import { faker } from '@faker-js/faker/locale/en';
-import { LEGACY_RUNTIME_IMAGE } from '../../constants/RuntimeImage.constants';
+import { RECOMMENDED_RUNTIME_IMAGE } from '../../constants/RuntimeImage.constants';
 import { CreateJobManifestRequest } from '../JobManifestTypes';
 
 export const createMockCreateJobManifestRequest = (
@@ -26,7 +26,7 @@ export const createMockCreateJobManifestRequest = (
     name: faker.lorem.word(),
     version,
     timeoutSeconds: faker.number.int({ max: 28800, min: 5 }),
-    image: LEGACY_RUNTIME_IMAGE,
+    image: RECOMMENDED_RUNTIME_IMAGE,
     autoRetry: false,
     ...partialRecord,
   };

package/src/domains/job/repository/JobExecutionRepository/JobExecutionRepository.spec.ts

@@ -381,6 +381,71 @@ describe('JobExecutionRepository', (): void => {
     });
   });
 
+  describe('getOldestQueuedExecution', () => {
+    const jobName = 'backed-up-job';
+
+    it('queries lsi1 for the oldest queued execution (ascending, limit 1)', async () => {
+      const mockJobExecution = createMockJobExecution({ jobName, status: JOB_EXECUTION_STATUS.queued });
+      dynamoClient.on(QueryCommand).resolvesOnce({ Items: [createMockJobExecutionDto(mockJobExecution)] });
+
+      const result = await jobExecutionRepository.getOldestQueuedExecution(jobName);
+
+      expect(result).toEqual(mockJobExecution);
+      expect(dynamoClient).toHaveReceivedCommandWith(QueryCommand, {
+        TableName: tableName,
+        IndexName: 'lsi1',
+        KeyConditionExpression: '#pk = :pk and #lsi1sk = :lsi1sk',
+        ExpressionAttributeNames: { '#pk': 'pk', '#lsi1sk': 'lsi1sk' },
+        ExpressionAttributeValues: {
+          ':pk': { S: `${ENTITY_TYPES.jobExecution}~${tenant}` },
+          ':lsi1sk': { S: `${JOB_EXECUTION_STATUS.queued}~${jobName}` },
+        },
+        ScanIndexForward: true,
+        Limit: 1,
+      });
+    });
+
+    it('returns null when there are no queued executions', async () => {
+      dynamoClient.on(QueryCommand).resolvesOnce({ Items: [] });
+
+      const result = await jobExecutionRepository.getOldestQueuedExecution(jobName);
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('countQueuedExecutions', () => {
+    const jobName = 'backed-up-job';
+
+    it('counts queued executions on lsi1 bounded by limit', async () => {
+      dynamoClient.on(QueryCommand).resolvesOnce({ Count: 501 });
+
+      const result = await jobExecutionRepository.countQueuedExecutions(jobName, 501);
+
+      expect(result).toBe(501);
+      expect(dynamoClient).toHaveReceivedCommandWith(QueryCommand, {
+        TableName: tableName,
+        IndexName: 'lsi1',
+        Select: 'COUNT',
+        KeyConditionExpression: '#pk = :pk and #lsi1sk = :lsi1sk',
+        ExpressionAttributeNames: { '#pk': 'pk', '#lsi1sk': 'lsi1sk' },
+        ExpressionAttributeValues: {
+          ':pk': { S: `${ENTITY_TYPES.jobExecution}~${tenant}` },
+          ':lsi1sk': { S: `${JOB_EXECUTION_STATUS.queued}~${jobName}` },
+        },
+        Limit: 501,
+      });
+    });
+
+    it('returns 0 when DynamoDB returns no count', async () => {
+      dynamoClient.on(QueryCommand).resolvesOnce({});
+
+      const result = await jobExecutionRepository.countQueuedExecutions(jobName, 501);
+
+      expect(result).toBe(0);
+    });
+  });
+
   describe('update', () => {
     it('Updates the record properties', async () => {
       const jobExecution = createMockJobExecution({ status: JOB_EXECUTION_STATUS.queued });

package/src/domains/job/repository/JobExecutionRepository/JobExecutionRepository.ts

@@ -9,6 +9,7 @@ import {
   QueryCommand,
   QueryCommandInput,
   QueryCommandOutput,
+  Select,
   UpdateItemCommand,
   UpdateItemCommandInput,
 } from '@aws-sdk/client-dynamodb';
@@ -136,6 +137,58 @@ export class JobExecutionRepository extends Repository<JobExecution, JobExecutio
     return results.map((item) => this.convertToItem(item as JobExecutionDto));
   }
 
+  /**
+   * Returns the single oldest queued execution for a job, or null if there are none.
+   *
+   * Queries the `lsi1` index (`lsi1sk = "<status>~<jobName>"`). All queued executions of one
+   * job share the same `lsi1sk`, so DynamoDB breaks ties by the base-table `sk`
+   * (`"<jobName>~<id>"`); `id` is prefixed with the ISO `timeQueued`, which sorts
+   * lexicographically, so ascending order is chronological and the first item is the oldest.
+   */
+  async getOldestQueuedExecution(jobName: string): Promise<JobExecution | null> {
+    const res = await this.dynamoDbClient.send(
+      new QueryCommand({
+        TableName: this.tableName,
+        IndexName: 'lsi1',
+        KeyConditionExpression: '#pk = :pk and #lsi1sk = :lsi1sk',
+        ExpressionAttributeNames: { '#pk': 'pk', '#lsi1sk': 'lsi1sk' },
+        ExpressionAttributeValues: {
+          ':pk': { S: this.pk },
+          ':lsi1sk': { S: `${JOB_EXECUTION_STATUS.queued}~${jobName}` },
+        },
+        ScanIndexForward: true,
+        Limit: 1,
+      }),
+    );
+
+    const item = res.Items?.[0];
+    return item ? this.convertToItem(item as JobExecutionDto) : null;
+  }
+
+  /**
+   * Counts queued executions for a job, evaluating at most `limit` items (`Select: COUNT` so no
+   * item data is returned). Pass a `limit` just above the threshold you care about — queued
+   * items are small, so a single page covers the bounded count.
+   */
+  async countQueuedExecutions(jobName: string, limit?: number): Promise<number> {
+    const res = await this.dynamoDbClient.send(
+      new QueryCommand({
+        TableName: this.tableName,
+        IndexName: 'lsi1',
+        Select: Select.COUNT,
+        KeyConditionExpression: '#pk = :pk and #lsi1sk = :lsi1sk',
+        ExpressionAttributeNames: { '#pk': 'pk', '#lsi1sk': 'lsi1sk' },
+        ExpressionAttributeValues: {
+          ':pk': { S: this.pk },
+          ':lsi1sk': { S: `${JOB_EXECUTION_STATUS.queued}~${jobName}` },
+        },
+        Limit: limit,
+      }),
+    );
+
+    return res.Count ?? 0;
+  }
+
   /**
    * Get list of records from database.
    * @abstract

package/src/domains/job/repository/JobManifestRepository/JobManifestRepository.spec.ts

@@ -13,7 +13,7 @@ import {
 } from '@aws-sdk/client-dynamodb';
 import { initIocContainer, iocContainer } from '../../../../mocks/mockIoc';
 import { ENTITY_TYPES } from '../../constants/Repository.constants';
-import { LEGACY_RUNTIME_IMAGE } from '../../constants/RuntimeImage.constants';
+import { RECOMMENDED_RUNTIME_IMAGE } from '../../constants/RuntimeImage.constants';
 import {
   createMockClientGetResponse,
   createMockClientPutResponse,
@@ -126,7 +126,7 @@ describe('JobManifestRepository', (): void => {
       expect(mockSend).toBeCalledTimes(1);
     });
 
-    it(`should default missing image to legacy runtime`, async (): Promise<void> => {
+    it(`should default missing image to the recommended runtime`, async (): Promise<void> => {
       const mockJobManifestItem = createMockJobManifestDto();
       delete (mockJobManifestItem as Partial<typeof mockJobManifestItem>).image;
 
@@ -143,12 +143,33 @@ describe('JobManifestRepository', (): void => {
       });
       expect(response).toEqual(
         expect.objectContaining({
-          image: LEGACY_RUNTIME_IMAGE,
+          image: RECOMMENDED_RUNTIME_IMAGE,
           autoRetry: false,
         }),
       );
     });
 
+    it('should remap deprecated node:20 runtime image to node:24', async (): Promise<void> => {
+      const mockJobManifestItem = createMockJobManifestDto({ image: 'node:20' });
+
+      mockSend.mockImplementationOnce(
+        (): GetItemCommandOutput =>
+          createMockClientGetResponse({
+            Item: mockJobManifestItem,
+          }),
+      );
+
+      const response = await jobManifestRepository.findOne({
+        name: mockJobManifestItem.name.S as string,
+        version: mockJobManifestItem.version.S as string,
+      });
+      expect(response).toEqual(
+        expect.objectContaining({
+          image: RECOMMENDED_RUNTIME_IMAGE,
+        }),
+      );
+    });
+
     it(`should default missing autoRetry to false`, async (): Promise<void> => {
       const mockJobManifestItem = createMockJobManifestDto();
       delete (mockJobManifestItem as Partial<typeof mockJobManifestItem>).autoRetry;

package/src/domains/job/repository/JobRepository/JobRepository.spec.ts

@@ -16,7 +16,7 @@ import {
 import { initIocContainer, iocContainer } from '../../../../mocks/mockIoc';
 import { InjectTokens } from '../../constants/InjectTokens';
 import { ENTITY_TYPES } from '../../constants/Repository.constants';
-import { LEGACY_RUNTIME_IMAGE } from '../../constants/RuntimeImage.constants';
+import { RECOMMENDED_RUNTIME_IMAGE } from '../../constants/RuntimeImage.constants';
 import {
   createMockClientGetResponse,
   createMockClientPutResponse,
@@ -176,7 +176,7 @@ describe('JobRepository', (): void => {
       expect(mockSend).toBeCalledTimes(1);
     });
 
-    it(`should default missing image to legacy runtime`, async (): Promise<void> => {
+    it(`should default missing image to the recommended runtime`, async (): Promise<void> => {
       const mockJobRecord = createMockJobDto();
       delete (mockJobRecord as Partial<typeof mockJobRecord>).image;
       mockSend.mockImplementationOnce(
@@ -193,7 +193,28 @@ describe('JobRepository', (): void => {
 
       expect(response).toEqual(
         expect.objectContaining({
-          image: LEGACY_RUNTIME_IMAGE,
+          image: RECOMMENDED_RUNTIME_IMAGE,
+        }),
+      );
+    });
+
+    it('should remap deprecated node:20 runtime image to node:24', async (): Promise<void> => {
+      const mockJobRecord = createMockJobDto({ image: 'node:20' });
+      mockSend.mockImplementationOnce(
+        (): GetItemCommandOutput =>
+          createMockClientGetResponse({
+            Item: mockJobRecord,
+          }),
+      );
+
+      const response = await jobRepository.findOne({
+        name: mockJobRecord.name.S as string,
+        version: mockJobRecord.version.S as string,
+      });
+
+      expect(response).toEqual(
+        expect.objectContaining({
+          image: RECOMMENDED_RUNTIME_IMAGE,
         }),
       );
     });

package/src/domains/job/services/JobExecutionTaskService/JobExecutionTaskService.spec.ts

@@ -31,7 +31,7 @@ describe('JobExecutionTaskService', () => {
     shortRegion: 'au',
     shortEnvironment: 'dev',
     clusterArn: `clusterArn`,
-    taskDefinitionArn: `legacyTaskDefinitionArn`,
+    taskDefinitionArn: `defaultTaskDefinitionArn`,
     taskDefinitionArnsByRuntimeImage: {
       'node:20': 'node20TaskDefinitionArn',
       'node:24': 'node24TaskDefinitionArn',
@@ -213,11 +213,11 @@ describe('JobExecutionTaskService', () => {
         defaultRunJobTaskParams.jobExecution,
       );
       expect(mockEcsClient).toHaveReceivedCommandWith(RunTaskCommand, {
-        taskDefinition: defaultRunJobTaskParams.taskDefinitionArnsByRuntimeImage['node:20'],
+        taskDefinition: defaultRunJobTaskParams.taskDefinitionArnsByRuntimeImage['node:24'],
       });
     });
 
-    it('should use the legacy task definition ARN when the node:20 map entry is missing', async () => {
+    it('should use the default task definition ARN when the node:24 map entry is missing', async () => {
       const mockArn = `mock-arn`;
 
       mockEcsClient.on(RunTaskCommand).resolves({ tasks: [{ taskArn: mockArn }] });
@@ -250,9 +250,8 @@ describe('JobExecutionTaskService', () => {
       await expect(
         jobExecutionTaskService.runJobExecutionTask({
           ...defaultRunJobTaskParams,
-          taskDefinitionArnsByRuntimeImage: {
-            'node:20': 'node20TaskDefinitionArn',
-          },
+          taskDefinitionArnsByRuntimeImage: {},
+          taskDefinitionArn: '',
         }),
       ).rejects.toThrow(RuntimeImageTaskDefinitionError);
       expect(mockEcsClient).not.toHaveReceivedCommand(RunTaskCommand);

package/src/domains/job/services/JobExecutionTaskService/JobExecutionTaskService.ts

@@ -61,7 +61,7 @@ export class JobExecutionTaskService {
     const taskDefinitionArn = resolveRuntimeImageTaskDefinitionArn({
       image: jobManifest?.image,
       taskDefinitionArnsByRuntimeImage: params.taskDefinitionArnsByRuntimeImage,
-      legacyTaskDefinitionArn: params.taskDefinitionArn,
+      defaultTaskDefinitionArn: params.taskDefinitionArn,
     });
     const jobDetailsFileUrl = await this.createJobDetailsFile(params.tenantId, params.jobExecution, jobManifest);
     const tags = getAwsTags({

package/src/domains/job/utils/ResolveRuntimeImageTaskDefinitionArn/ResolveRuntimeImageTaskDefinitionArn.spec.ts

@@ -0,0 +1,64 @@
+/*!
+ * @license
+ * Copyright Squiz Australia Pty Ltd. All Rights Reserved.
+ */
+
+import { RuntimeImageTaskDefinitionError } from '../../errors';
+import { resolveRuntimeImageTaskDefinitionArn } from './ResolveRuntimeImageTaskDefinitionArn';
+
+describe('resolveRuntimeImageTaskDefinitionArn', () => {
+  const taskDefinitionArnsByRuntimeImage = {
+    'node:24': 'node24TaskDefinitionArn',
+  };
+  const defaultTaskDefinitionArn = 'defaultTaskDefinitionArn';
+
+  it('resolves node:24 when the stored image is deprecated node:20', () => {
+    expect(
+      resolveRuntimeImageTaskDefinitionArn({
+        image: 'node:20',
+        taskDefinitionArnsByRuntimeImage,
+        defaultTaskDefinitionArn,
+      }),
+    ).toEqual('node24TaskDefinitionArn');
+  });
+
+  it('resolves node:24 when the stored image is missing', () => {
+    expect(
+      resolveRuntimeImageTaskDefinitionArn({
+        image: undefined,
+        taskDefinitionArnsByRuntimeImage,
+        defaultTaskDefinitionArn,
+      }),
+    ).toEqual('node24TaskDefinitionArn');
+  });
+
+  it('uses the default task definition ARN when the runtime map entry is missing', () => {
+    expect(
+      resolveRuntimeImageTaskDefinitionArn({
+        image: 'node:20',
+        taskDefinitionArnsByRuntimeImage: {},
+        defaultTaskDefinitionArn,
+      }),
+    ).toEqual(defaultTaskDefinitionArn);
+  });
+
+  it('throws when the runtime image is unsupported', () => {
+    expect(() =>
+      resolveRuntimeImageTaskDefinitionArn({
+        image: 'node:26',
+        taskDefinitionArnsByRuntimeImage,
+        defaultTaskDefinitionArn,
+      }),
+    ).toThrow(RuntimeImageTaskDefinitionError);
+  });
+
+  it('throws when no task definition ARN is configured for the runtime image', () => {
+    expect(() =>
+      resolveRuntimeImageTaskDefinitionArn({
+        image: 'node:24',
+        taskDefinitionArnsByRuntimeImage: {},
+        defaultTaskDefinitionArn: '',
+      }),
+    ).toThrow(RuntimeImageTaskDefinitionError);
+  });
+});

package/src/domains/job/utils/ResolveRuntimeImageTaskDefinitionArn/ResolveRuntimeImageTaskDefinitionArn.ts

@@ -4,7 +4,6 @@
  */
 
 import {
-  LEGACY_RUNTIME_IMAGE,
   SUPPORTED_RUNTIME_IMAGES,
   getRuntimeImageOrDefault,
   isSupportedRuntimeImage,
@@ -15,7 +14,7 @@ import { ResolveRuntimeImageTaskDefinitionArnParams } from './ResolveRuntimeImag
 export const resolveRuntimeImageTaskDefinitionArn = ({
   image,
   taskDefinitionArnsByRuntimeImage,
-  legacyTaskDefinitionArn,
+  defaultTaskDefinitionArn,
 }: ResolveRuntimeImageTaskDefinitionArnParams): string => {
   const runtimeImage = getRuntimeImageOrDefault(image);
 
@@ -25,9 +24,7 @@ export const resolveRuntimeImageTaskDefinitionArn = ({
     );
   }
 
-  const taskDefinitionArn =
-    taskDefinitionArnsByRuntimeImage[runtimeImage] ||
-    (runtimeImage === LEGACY_RUNTIME_IMAGE ? legacyTaskDefinitionArn : undefined);
+  const taskDefinitionArn = taskDefinitionArnsByRuntimeImage[runtimeImage] || defaultTaskDefinitionArn;
 
   if (!taskDefinitionArn) {
     throw new RuntimeImageTaskDefinitionError(

package/src/domains/job/utils/ResolveRuntimeImageTaskDefinitionArn/ResolveRuntimeImageTaskDefinitionArn.types.ts

@@ -6,5 +6,5 @@
 export interface ResolveRuntimeImageTaskDefinitionArnParams {
   image: string | null | undefined;
   taskDefinitionArnsByRuntimeImage: Record<string, string>;
-  legacyTaskDefinitionArn: string;
+  defaultTaskDefinitionArn: string;
 }

package/src/domains/manifest/utils/validateRuntimeImage.spec.ts

@@ -3,7 +3,6 @@
  * Copyright Squiz Australia Pty Ltd. All Rights Reserved.
  */
 
-import * as runtimeImageConstants from '../../job/constants/RuntimeImage.constants';
 import {
   DEPRECATED_RUNTIME_IMAGES,
   RECOMMENDED_RUNTIME_IMAGE,
@@ -13,10 +12,6 @@ import { ManifestValidationError } from '../errors/ManifestValidationError';
 import { validateAndDefaultRuntimeImage } from './validateRuntimeImage';
 
 describe('validateAndDefaultRuntimeImage', () => {
-  afterEach(() => {
-    jest.restoreAllMocks();
-  });
-
   it('returns the recommended runtime image when image is undefined', () => {
     expect(validateAndDefaultRuntimeImage(undefined)).toEqual(RECOMMENDED_RUNTIME_IMAGE);
   });
@@ -38,9 +33,6 @@ describe('validateAndDefaultRuntimeImage', () => {
   });
 
   it('throws ManifestValidationError when the image is deprecated', () => {
-    jest.spyOn(runtimeImageConstants, 'isSupportedRuntimeImage').mockReturnValue(true);
-    jest.spyOn(runtimeImageConstants, 'isDeprecatedRuntimeImage').mockReturnValue(true);
-
     expect(() => validateAndDefaultRuntimeImage('node:20')).toThrow(ManifestValidationError);
     expect(() => validateAndDefaultRuntimeImage('node:20')).toThrow(/deprecated/);
   });

package/src/domains/manifest/utils/validateRuntimeImage.ts

@@ -16,16 +16,16 @@ export const validateAndDefaultRuntimeImage = (image: string | null | undefined)
     return RECOMMENDED_RUNTIME_IMAGE;
   }
 
-  if (!isSupportedRuntimeImage(image)) {
+  if (isDeprecatedRuntimeImage(image)) {
     throw new ManifestValidationError(
-      `Unsupported runtime image "${image}". Supported images are: ${SUPPORTED_RUNTIME_IMAGES.join(', ')}`,
+      `Runtime image "${image}" is deprecated and can no longer be used for new uploads. ` +
+        `Please use the recommended runtime image "${RECOMMENDED_RUNTIME_IMAGE}".`,
     );
   }
 
-  if (isDeprecatedRuntimeImage(image)) {
+  if (!isSupportedRuntimeImage(image)) {
     throw new ManifestValidationError(
-      `Runtime image "${image}" is deprecated and can no longer be used for new uploads. ` +
-        `Please use the recommended runtime image "${RECOMMENDED_RUNTIME_IMAGE}".`,
+      `Unsupported runtime image "${image}". Supported images are: ${SUPPORTED_RUNTIME_IMAGES.join(', ')}`,
     );
   }