@squiz/job-runner-lib 2.7.0 → 2.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@squiz/job-runner-lib",
-  "version": "2.7.0",
+  "version": "2.9.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/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/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

@@ -11,12 +11,18 @@ export const LEGACY_RUNTIME_IMAGE = 'node:20';
 export const RECOMMENDED_RUNTIME_IMAGE = 'node:24';
 
 // Still runnable but rejected on new uploads.
-export const DEPRECATED_RUNTIME_IMAGES: readonly string[] = [];
+export const DEPRECATED_RUNTIME_IMAGES: readonly string[] = ['node:20'];
 
 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/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/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/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

@@ -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 => {