@squiz/job-runner-lib 2.7.0 → 2.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@squiz/job-runner-lib",
-  "version": "2.7.0",
+  "version": "2.8.0",
   "description": "",
   "main": "lib/index.js",
   "private": false,
@@ -35,7 +35,7 @@
     "@aws-sdk/client-sqs": "3.1003.0",
     "@aws-sdk/s3-request-presigner": "3.1003.0",
     "@squiz/dx-common-lib": "1.66.1",
-    "@squiz/dx-json-schema-lib": "1.85.0",
+    "@squiz/dx-json-schema-lib": "1.86.0",
     "@squiz/dx-logger-lib": "1.64.0",
     "@squiz/optimization-logger": "1.11.2",
     "axios": "1.16.1",

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

@@ -7,15 +7,21 @@
  * Retry configuration with exponential backoff delays in seconds.
  * Using SQS message timer limits (max 15 minutes = 900 seconds).
  *
- * Delays: 30s, 1min, 2min, 5min, 10min, 15min
+ * Delays: 30s, 1min, 2min, 5min, 10min, then 15min thereafter.
  */
-export const RETRY_DELAYS_SECONDS: ReadonlyArray<number> = [30, 60, 120, 300, 600, 900];
+export const RETRY_DELAYS_SECONDS: ReadonlyArray<number> = [30, 60, 120, 300, 600, 900, 900, 900, 900, 900];
 
 /**
  * Maximum number of retry attempts for container start failures.
  */
 export const MAX_RETRY_ATTEMPTS = RETRY_DELAYS_SECONDS.length;
 
+/**
+ * Maximum number of total attempts for opted-in job code failures.
+ * This allows the initial attempt plus 3 retries.
+ */
+export const MAX_JOB_CODE_RETRY_ATTEMPTS = 4;
+
 /**
  * After a job has attempted to be started this number of times alerts will start to be sent.
  */

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

@@ -14,9 +14,15 @@ export const RECOMMENDED_RUNTIME_IMAGE = 'node:24';
 export const DEPRECATED_RUNTIME_IMAGES: readonly string[] = [];
 
 export const getRuntimeImageOrDefault = (image: string | null | undefined): string =>
-  image && isSupportedRuntimeImage(image) ? image : LEGACY_RUNTIME_IMAGE;
+  image === null || image === undefined ? LEGACY_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],
+  recommendedRuntimeImage: RECOMMENDED_RUNTIME_IMAGE,
+});

package/src/domains/job/errors/RuntimeImageTaskDefinitionError.ts

@@ -0,0 +1,10 @@
+/*!
+ * @license
+ * Copyright Squiz Australia Pty Ltd. All Rights Reserved.
+ */
+
+export class RuntimeImageTaskDefinitionError extends Error {
+  constructor(message: string) {
+    super(message);
+  }
+}

package/src/domains/job/errors/index.ts

@@ -6,3 +6,4 @@ export * from './NotFoundError';
 export * from './NotImplementedError';
 export * from './UnprocessableContent';
 export * from './ExecutionStatusError';
+export * from './RuntimeImageTaskDefinitionError';

package/src/domains/job/manifest/JobManifestTypes.ts

@@ -64,6 +64,13 @@ export interface JobManifest {
    */
   image: string;
 
+  /**
+   * Whether failed job code executions should be retried automatically.
+   * @type {boolean}
+   * @memberof JobManifest
+   */
+  autoRetry: boolean;
+
   /**
    * The DynamoDB record type ('job').
    * @type {EntityType}
@@ -142,6 +149,13 @@ export interface JobManifestRecord {
    * @memberof JobManifestRecord
    */
   image: string;
+
+  /**
+   * Whether failed job code executions should be retried automatically.
+   * @type {boolean}
+   * @memberof JobManifestRecord
+   */
+  autoRetry: boolean;
 }
 
 export type JobManifestDto = Record<keyof JobManifestRecord, AttributeValue>;
@@ -150,7 +164,8 @@ export type JobManifestDto = Record<keyof JobManifestRecord, AttributeValue>;
  * The request body for creating a job (POST /job-manifest).
  * @export
  */
-export type CreateJobManifestRequest = Omit<JobManifest, 'type'>;
+export type CreateJobManifestRequest = Omit<JobManifest, 'type' | 'autoRetry'> &
+  Partial<Pick<JobManifest, 'autoRetry'>>;
 
 /**
  * The request body for updating a job (PUT /job-manifest).

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

@@ -26,6 +26,7 @@ export const createMockJobManifest = (partialRecord: Partial<JobManifest> = {}):
     version,
     timeoutSeconds: faker.number.int({ max: 28800, min: 5 }),
     image: LEGACY_RUNTIME_IMAGE,
+    autoRetry: false,
     type: ENTITY_TYPES.manifest,
     ...partialRecord,
   };

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

@@ -42,6 +42,9 @@ export const createMockJobManifestDto = (partialRecord: Partial<JobManifestRecor
     image: {
       S: partialRecord.image ?? LEGACY_RUNTIME_IMAGE,
     },
+    autoRetry: {
+      BOOL: partialRecord.autoRetry ?? false,
+    },
   };
 };
 

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

@@ -30,6 +30,7 @@ export const createMockJobManifestRecord = (partialRecord: Partial<JobManifestRe
     version,
     timeoutSeconds: faker.number.int({ max: 28800, min: 5 }),
     image: LEGACY_RUNTIME_IMAGE,
+    autoRetry: false,
     ...partialRecord,
   };
 };

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

@@ -27,6 +27,7 @@ export const createMockCreateJobManifestRequest = (
     version,
     timeoutSeconds: faker.number.int({ max: 28800, min: 5 }),
     image: LEGACY_RUNTIME_IMAGE,
+    autoRetry: false,
     ...partialRecord,
   };
 };

package/src/domains/job/model/Job/Job.ts

@@ -34,6 +34,13 @@ export interface Job {
    */
   version: string;
 
+  /**
+   * The runtime image the job should execute against (e.g. `node:20`, `node:24`).
+   * @type {string}
+   * @memberof Job
+   */
+  image: string;
+
   /**
    * The DynamoDB record type ('job').
    * @type {EntityType}
@@ -82,6 +89,13 @@ export interface JobRecord {
    * @memberof JobRecord
    */
   version: string;
+
+  /**
+   * The runtime image the job should execute against (e.g. `node:20`, `node:24`).
+   * @type {string}
+   * @memberof JobRecord
+   */
+  image: string;
 }
 
 export type JobDto = Record<keyof JobRecord, AttributeValue>;

package/src/domains/job/model/Job/mocks/Job.mock.ts

@@ -5,6 +5,7 @@
 
 import { faker } from '@faker-js/faker/locale/en';
 import { ENTITY_TYPES } from '../../../constants/Repository.constants';
+import { RECOMMENDED_RUNTIME_IMAGE } from '../../../constants/RuntimeImage.constants';
 import { Job } from '../Job';
 
 export const createMockJob = (partialRecord: Partial<Job> = {}): Job => {
@@ -16,6 +17,7 @@ export const createMockJob = (partialRecord: Partial<Job> = {}): Job => {
     description: faker.lorem.sentence(),
     type: ENTITY_TYPES.job,
     version: version,
+    image: RECOMMENDED_RUNTIME_IMAGE,
     ...partialRecord,
   };
 };

package/src/domains/job/model/Job/mocks/JobDto.mock.ts

@@ -5,6 +5,7 @@
 
 import { faker } from '@faker-js/faker/locale/en';
 import { ENTITY_TYPES } from '../../../constants/Repository.constants';
+import { RECOMMENDED_RUNTIME_IMAGE } from '../../../constants/RuntimeImage.constants';
 import { JobDto, JobRecord } from '../Job';
 
 export const createMockJobDto = (partialRecord: Partial<JobRecord> = {}): JobDto => {
@@ -29,6 +30,9 @@ export const createMockJobDto = (partialRecord: Partial<JobRecord> = {}): JobDto
     version: {
       S: partialRecord.version ?? version,
     },
+    image: {
+      S: partialRecord.image ?? RECOMMENDED_RUNTIME_IMAGE,
+    },
   };
 };
 

package/src/domains/job/model/Job/mocks/JobRecord.mock.ts

@@ -5,6 +5,7 @@
 
 import { faker } from '@faker-js/faker/locale/en';
 import { ENTITY_TYPES } from '../../../constants/Repository.constants';
+import { RECOMMENDED_RUNTIME_IMAGE } from '../../../constants/RuntimeImage.constants';
 import { JobRecord } from '../Job';
 
 export const createMockJobRecord = (partialRecord: Partial<JobRecord> = {}): JobRecord => {
@@ -19,6 +20,7 @@ export const createMockJobRecord = (partialRecord: Partial<JobRecord> = {}): Job
     name: faker.lorem.word(),
     description: faker.lorem.sentence(),
     version,
+    image: RECOMMENDED_RUNTIME_IMAGE,
     ...partialRecord,
   };
 };

package/src/domains/job/model/Job/mocks/JobRequest.mock.ts

@@ -4,6 +4,7 @@
  */
 
 import { faker } from '@faker-js/faker/locale/en';
+import { RECOMMENDED_RUNTIME_IMAGE } from '../../../constants/RuntimeImage.constants';
 import { CreateJobRequest } from '../Job';
 
 export const createMockCreateJobRequest = (partialRecord: Partial<CreateJobRequest> = {}): CreateJobRequest => {
@@ -15,6 +16,7 @@ export const createMockCreateJobRequest = (partialRecord: Partial<CreateJobReque
     name: faker.lorem.word(),
     description: faker.lorem.sentence(),
     version,
+    image: RECOMMENDED_RUNTIME_IMAGE,
     ...partialRecord,
   };
 };

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

@@ -12,21 +12,21 @@ import {
   ScanCommandOutput,
 } 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 {
+  createMockClientGetResponse,
   createMockClientPutResponse,
   createMockClientScanResponse,
-  createMockClientGetResponse,
 } from '../../core/dynamoClient.mock';
-import { ENTITY_TYPES } from '../../constants/Repository.constants';
 import {
   JobManifest,
+  createMockCreateJobManifestRequest,
   createMockJobManifest,
   createMockJobManifestDto,
   createMockJobManifestDtos,
   createMockJobManifestRecord,
-  createMockCreateJobManifestRequest,
 } from '../../manifest';
-import { LEGACY_RUNTIME_IMAGE } from '../../constants/RuntimeImage.constants';
 import { JobManifestRepository } from './JobManifestRepository';
 
 initIocContainer();
@@ -120,6 +120,7 @@ describe('JobManifestRepository', (): void => {
         entryFunction: JSON.parse(mockJobManifestItem.entryFunction.S as string),
         timeoutSeconds: parseInt(mockJobManifestItem.timeoutSeconds.N as string),
         image: 'node:24',
+        autoRetry: false,
         type: `manifest`,
       } as JobManifest);
       expect(mockSend).toBeCalledTimes(1);
@@ -143,6 +144,51 @@ describe('JobManifestRepository', (): void => {
       expect(response).toEqual(
         expect.objectContaining({
           image: LEGACY_RUNTIME_IMAGE,
+          autoRetry: false,
+        }),
+      );
+    });
+
+    it(`should default missing autoRetry to false`, async (): Promise<void> => {
+      const mockJobManifestItem = createMockJobManifestDto();
+      delete (mockJobManifestItem as Partial<typeof mockJobManifestItem>).autoRetry;
+
+      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({
+          autoRetry: false,
+        }),
+      );
+    });
+
+    it(`should preserve an explicit unsupported runtime image`, async (): Promise<void> => {
+      const mockJobManifestItem = createMockJobManifestDto({ image: 'node:26' });
+
+      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: 'node:26',
         }),
       );
     });
@@ -221,6 +267,12 @@ describe('JobManifestRepository', (): void => {
       const dto = jobManifestRepository.convertToDynamoDbItem(manifest);
       expect(dto.image).toEqual({ S: 'node:24' });
     });
+
+    it(`should persist autoRetry on the DynamoDB item`, () => {
+      const manifest = createMockJobManifest({ autoRetry: true });
+      const dto = jobManifestRepository.convertToDynamoDbItem(manifest);
+      expect(dto.autoRetry).toEqual({ BOOL: true });
+    });
   });
 
   describe('delete', () => {

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

@@ -5,9 +5,10 @@
 
 import { AttributeValue, DynamoDBClient, UpdateItemCommand, UpdateItemCommandInput } from '@aws-sdk/client-dynamodb';
 import { inject } from 'inversify';
-import { provideTransient } from '../../transientProvider';
-import { Repository } from '../AbstractRepository';
+import { defaultAutoRetry } from '../../../manifest/utils/defaultAutoRetry';
+import { InjectTokens } from '../../constants/InjectTokens';
 import { ENTITY_TYPES } from '../../constants/Repository.constants';
+import { getRuntimeImageOrDefault } from '../../constants/RuntimeImage.constants';
 import {
   CreateJobManifestRequest,
   JobManifest,
@@ -15,9 +16,9 @@ import {
   JobManifestSk,
   UpdateJobManifestRequest,
 } from '../../manifest';
-import { InjectTokens } from '../../constants/InjectTokens';
-import { getRuntimeImageOrDefault } from '../../constants/RuntimeImage.constants';
 import { parsePartitionKey } from '../../ParsePartitionKey';
+import { provideTransient } from '../../transientProvider';
+import { Repository } from '../AbstractRepository';
 
 @provideTransient(JobManifestRepository)
 export class JobManifestRepository extends Repository<JobManifest, JobManifestDto, JobManifestSk> {
@@ -32,6 +33,7 @@ export class JobManifestRepository extends Repository<JobManifest, JobManifestDt
   public async create(input: CreateJobManifestRequest): Promise<JobManifest> {
     const newJobManifest: JobManifest = {
       ...input,
+      autoRetry: defaultAutoRetry(input.autoRetry),
       type: ENTITY_TYPES.manifest,
     };
 
@@ -74,6 +76,11 @@ export class JobManifestRepository extends Repository<JobManifest, JobManifestDt
       expressionAttributeValues[':image'] = { S: input.image };
     }
 
+    if (input.autoRetry !== undefined) {
+      expressionAttributeNames['#autoRetry'] = 'autoRetry';
+      expressionAttributeValues[':autoRetry'] = { BOOL: input.autoRetry };
+    }
+
     const updateExpressionPairs = Object.keys(input).map((key) => `#${key} = :${key}`);
     const updateExpression = `SET ${updateExpressionPairs.join(', ')}`;
 
@@ -98,12 +105,14 @@ export class JobManifestRepository extends Repository<JobManifest, JobManifestDt
       sk: { S: `${item.name}~${item.version}` },
       timeoutSeconds: { N: item.timeoutSeconds.toString() },
       image: { S: item.image },
+      autoRetry: { BOOL: item.autoRetry },
     };
   }
 
   convertToItem(dbItem: JobManifestDto): JobManifest {
     const { pk, name, version, concurrency, entryFile, entryFunction, timeoutSeconds } = dbItem;
     const image = (dbItem as Partial<JobManifestDto>).image?.S;
+    const autoRetry = (dbItem as Partial<JobManifestDto>).autoRetry?.BOOL;
     return {
       concurrency: parseInt(concurrency.N as string),
       entryFile: entryFile.S as string,
@@ -112,6 +121,7 @@ export class JobManifestRepository extends Repository<JobManifest, JobManifestDt
       version: version.S as string,
       timeoutSeconds: parseInt(timeoutSeconds.N as string),
       image: getRuntimeImageOrDefault(image),
+      autoRetry: defaultAutoRetry(autoRetry),
       type: parsePartitionKey(pk.S as string).entityType,
     };
   }

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

@@ -14,21 +14,22 @@ import {
   ScanCommandOutput,
 } from '@aws-sdk/client-dynamodb';
 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 {
+  createMockClientGetResponse,
   createMockClientPutResponse,
   createMockClientScanResponse,
-  createMockClientGetResponse,
 } from '../../core/dynamoClient.mock';
-import { ENTITY_TYPES } from '../../constants/Repository.constants';
 import { PaginationInfo } from '../../core/pagination/model/PaginationInfo';
 import { PAGINATION_DIRECTION_TYPE_BEFORE } from '../../core/pagination/model/PaginationTypes';
 import * as PaginationUtils from '../../core/pagination/utils/PaginationUtils';
+import { createMockJob, createMockJobRecord } from '../../model/Job';
 import { Job } from '../../model/Job/Job';
 import { createMockJobDto, createMockJobDtos } from '../../model/Job/mocks/JobDto.mock';
 import { createMockCreateJobRequest } from '../../model/Job/mocks/JobRequest.mock';
 import { JobRepository } from './JobRepository';
-import { createMockJob, createMockJobRecord } from '../../model/Job';
-import { InjectTokens } from '../../constants/InjectTokens';
 
 initIocContainer();
 
@@ -170,10 +171,33 @@ describe('JobRepository', (): void => {
         type: `job`,
         version: mockJobRecord.version.S as string,
         description: mockJobRecord.description.S as string,
+        image: mockJobRecord.image.S as string,
       } as Job);
       expect(mockSend).toBeCalledTimes(1);
     });
 
+    it(`should default missing image to legacy runtime`, async (): Promise<void> => {
+      const mockJobRecord = createMockJobDto();
+      delete (mockJobRecord as Partial<typeof mockJobRecord>).image;
+      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: LEGACY_RUNTIME_IMAGE,
+        }),
+      );
+    });
+
     it(`should return null if job does not exist`, async (): Promise<void> => {
       mockSend.mockImplementationOnce(
         (): ScanCommandOutput =>
@@ -313,6 +337,14 @@ describe('JobRepository', (): void => {
     });
   });
 
+  describe('convertToDynamoDbItem', () => {
+    it(`should persist image on the DynamoDB item`, () => {
+      const job = createMockJob({ image: 'node:24' });
+      const dto = jobRepository.convertToDynamoDbItem(job);
+      expect(dto.image).toEqual({ S: 'node:24' });
+    });
+  });
+
   describe('delete', () => {
     it(`should return undefined when calling the delete operation`, async (): Promise<void> => {
       mockSend.mockImplementationOnce((): DeleteItemCommandOutput => {

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

@@ -11,18 +11,19 @@ import {
   QueryCommandOutput,
 } from '@aws-sdk/client-dynamodb';
 import { inject } from 'inversify';
-import { provideTransient } from '../../transientProvider';
-import { Repository } from '../AbstractRepository';
+import { InjectTokens } from '../../constants/InjectTokens';
 import { ENTITY_TYPES } from '../../constants/Repository.constants';
-import { parsePartitionKey } from '../../ParsePartitionKey';
-import { CreateJobRequest, Job, JobDto, JobSk, ListJobParameters } from '../../model/Job';
+import { getRuntimeImageOrDefault } from '../../constants/RuntimeImage.constants';
 import {
   decodeTokenString,
   PAGINATION_DIRECTION_TYPE_BEFORE,
   PaginationInfo,
   PaginationQueryResponse,
 } from '../../core/pagination';
-import { InjectTokens } from '../../constants/InjectTokens';
+import { CreateJobRequest, Job, JobDto, JobSk, ListJobParameters } from '../../model/Job';
+import { parsePartitionKey } from '../../ParsePartitionKey';
+import { provideTransient } from '../../transientProvider';
+import { Repository } from '../AbstractRepository';
 
 @provideTransient(JobRepository)
 export class JobRepository extends Repository<Job, JobDto, JobSk> {
@@ -37,6 +38,7 @@ export class JobRepository extends Repository<Job, JobDto, JobSk> {
   public async create(input: CreateJobRequest): Promise<Job> {
     const newJob: Job = {
       ...input,
+      image: getRuntimeImageOrDefault(input.image),
       type: ENTITY_TYPES.job,
     };
 
@@ -157,11 +159,13 @@ export class JobRepository extends Repository<Job, JobDto, JobSk> {
       name: { S: item.name },
       description: item.description ? { S: item.description } : { NULL: true },
       version: { S: item.version },
+      image: { S: item.image },
     };
   }
 
   convertToItem(dbItem: JobDto): Job {
     const { pk, name, version } = dbItem;
+    const image = (dbItem as Partial<JobDto>).image?.S;
     let description;
     // TODO https://jira.squiz.net/browse/CONN-609 remove this check if we tidy up
     // jobs added before this field was implemented
@@ -175,6 +179,7 @@ export class JobRepository extends Repository<Job, JobDto, JobSk> {
       description: description.S ? (description.S as string) : '',
       type: parsePartitionKey(pk.S as string).entityType,
       version: version.S as string,
+      image: getRuntimeImageOrDefault(image),
     };
   }
 

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

@@ -17,5 +17,6 @@ export interface RunJobTaskParams {
   shortEnvironment: string;
   clusterArn: string;
   taskDefinitionArn: string;
+  taskDefinitionArnsByRuntimeImage: Record<string, string>;
   tenantId: string;
 }

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

@@ -4,6 +4,7 @@ import { AwsClientStub, mockClient } from 'aws-sdk-client-mock';
 import 'aws-sdk-client-mock-jest';
 import { JobDetailsRepository, JobUploadsRepository } from '../../S3Repository';
 import { JOB_EXECUTION_STATUS } from '../../constants/JobExecutionStatus.constants';
+import { RuntimeImageTaskDefinitionError } from '../../errors';
 import { createMockJobManifest } from '../../manifest';
 import { createMockJobContext } from '../../model/JobContext';
 import { createMockJobExecution } from '../../model/JobExecution';
@@ -30,7 +31,11 @@ describe('JobExecutionTaskService', () => {
     shortRegion: 'au',
     shortEnvironment: 'dev',
     clusterArn: `clusterArn`,
-    taskDefinitionArn: `taskDefinitionArn`,
+    taskDefinitionArn: `legacyTaskDefinitionArn`,
+    taskDefinitionArnsByRuntimeImage: {
+      'node:20': 'node20TaskDefinitionArn',
+      'node:24': 'node24TaskDefinitionArn',
+    },
     tenantId: 'some_tenant',
   };
 
@@ -104,7 +109,7 @@ describe('JobExecutionTaskService', () => {
       const mockArn = `mock-arn`;
       const mockTask = { taskArn: mockArn };
       const jobContext = createMockJobContext();
-      const jobManifest = createMockJobManifest();
+      const jobManifest = createMockJobManifest({ image: 'node:24' });
       const jobExecution = createMockJobExecution({
         id: `20250917T005949395Z-9602417782`,
         jobName: 'jobName',
@@ -173,7 +178,7 @@ describe('JobExecutionTaskService', () => {
           { key: 'map-migrated', value: 'migUJ1IX3DUXG' },
           { key: 'cmp:tenant', value: 'some_tenant' },
         ],
-        taskDefinition: defaultRunJobTaskParams.taskDefinitionArn,
+        taskDefinition: defaultRunJobTaskParams.taskDefinitionArnsByRuntimeImage['node:24'],
         // sha1 of execution job name/id + tenant + retryCount.
         clientToken: '4725755e08138edde031a177c36a269ecdbed5a3',
       });
@@ -207,6 +212,51 @@ describe('JobExecutionTaskService', () => {
         null,
         defaultRunJobTaskParams.jobExecution,
       );
+      expect(mockEcsClient).toHaveReceivedCommandWith(RunTaskCommand, {
+        taskDefinition: defaultRunJobTaskParams.taskDefinitionArnsByRuntimeImage['node:20'],
+      });
+    });
+
+    it('should use the legacy task definition ARN when the node:20 map entry is missing', async () => {
+      const mockArn = `mock-arn`;
+
+      mockEcsClient.on(RunTaskCommand).resolves({ tasks: [{ taskArn: mockArn }] });
+      mockJobContextService.findJobContext.mockResolvedValue(createMockJobContext());
+      mockJobManifestService.findJobManifest.mockResolvedValue(createMockJobManifest({ image: 'node:20' }));
+
+      await jobExecutionTaskService.runJobExecutionTask({
+        ...defaultRunJobTaskParams,
+        taskDefinitionArnsByRuntimeImage: {},
+      });
+
+      expect(mockEcsClient).toHaveReceivedCommandWith(RunTaskCommand, {
+        taskDefinition: defaultRunJobTaskParams.taskDefinitionArn,
+      });
+    });
+
+    it('should throw before creating an ECS task when the runtime image is unsupported', async () => {
+      mockJobManifestService.findJobManifest.mockResolvedValue(createMockJobManifest({ image: 'node:26' }));
+
+      await expect(jobExecutionTaskService.runJobExecutionTask(defaultRunJobTaskParams)).rejects.toThrow(
+        RuntimeImageTaskDefinitionError,
+      );
+      expect(mockEcsClient).not.toHaveReceivedCommand(RunTaskCommand);
+      expect(mockJobDetailsRepository.createJobDetailsFile).not.toHaveBeenCalled();
+    });
+
+    it('should throw before creating an ECS task when the runtime image has no task definition ARN', async () => {
+      mockJobManifestService.findJobManifest.mockResolvedValue(createMockJobManifest({ image: 'node:24' }));
+
+      await expect(
+        jobExecutionTaskService.runJobExecutionTask({
+          ...defaultRunJobTaskParams,
+          taskDefinitionArnsByRuntimeImage: {
+            'node:20': 'node20TaskDefinitionArn',
+          },
+        }),
+      ).rejects.toThrow(RuntimeImageTaskDefinitionError);
+      expect(mockEcsClient).not.toHaveReceivedCommand(RunTaskCommand);
+      expect(mockJobDetailsRepository.createJobDetailsFile).not.toHaveBeenCalled();
     });
 
     it('should handle ConflictException with a previously started task arn', async () => {