@squiz/job-runner-lib 2.2.0 → 2.4.0

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

@@ -3,58 +3,60 @@
  * Copyright Squiz Australia Pty Ltd. All Rights Reserved.
  */
 
-import * as dotenv from 'dotenv';
-dotenv.config();
-
 import {
   AttributeValue,
   DynamoDBClient,
-  GetItemCommand,
-  GetItemCommandInput,
-  PutItemCommand,
   QueryCommand,
   QueryCommandInput,
-  ScanCommand,
-  ScanCommandOutput,
+  QueryCommandOutput,
   UpdateItemCommand,
   UpdateItemCommandInput,
 } from '@aws-sdk/client-dynamodb';
 import { randomInt } from 'crypto';
 import { inject } from 'inversify';
-import { parsePartitionKey } from '../../ParsePartitionKey';
 import { JOB_EXECUTION_STATUS } from '../../constants/JobExecutionStatus.constants';
-import { JobExecutionPk, PARTITION_KEYS } from '../../constants/Repository.constants';
-import { PaginationInfo } from '../../core/pagination/model/PaginationInfo';
-import { PaginationQueryResponse } from '../../core/pagination/model/PaginationQueryResponse';
-import { PAGINATION_DIRECTION_TYPE_AFTER } from '../../core/pagination/model/PaginationTypes';
-import { decodeTokenString } from '../../core/pagination/utils/PaginationUtils';
-import { InternalServerError } from '../../errors';
+import { ENTITY_TYPES } from '../../constants/Repository.constants';
+import {
+  PaginationInfo,
+  PaginationQueryResponse,
+  PAGINATION_DIRECTION_TYPE_AFTER,
+  decodeTokenString,
+} from '../../core/pagination';
 import {
   CreateJobExecutionRequest,
   JobExecution,
   JobExecutionDto,
+  JobExecutionSk,
   ListJobExecutionParameters,
   UpdateJobExecutionParameters,
-} from '../../model/JobExecution/JobExecution';
+} from '../../model/JobExecution';
 import { provideTransient } from '../../transientProvider';
 import { Repository } from '../AbstractRepository';
+import { InjectTokens } from '../../constants/InjectTokens';
+import { convertDynamoDbItemToJobExecution } from './utils';
 
 @provideTransient(JobExecutionRepository)
-export class JobExecutionRepository extends Repository<JobExecution, JobExecutionDto> {
-  public constructor(@inject(DynamoDBClient) protected dynamoDbClient: DynamoDBClient) {
-    super(dynamoDbClient);
-    this.tableName = process.env.DYNAMODB_TABLE as string;
+export class JobExecutionRepository extends Repository<JobExecution, JobExecutionDto, JobExecutionSk> {
+  public constructor(
+    @inject(DynamoDBClient) dynamoDbClient: DynamoDBClient,
+    @inject(InjectTokens.DynamoTableName) tableName: string,
+    @inject(InjectTokens.Tenant) tenant?: string,
+  ) {
+    super(dynamoDbClient, tableName, `${ENTITY_TYPES.jobExecution}~${tenant}`);
   }
 
   public async begin(createParams: CreateJobExecutionRequest): Promise<JobExecution> {
     const newJobQueueTime = new Date().toISOString();
     const newJobId = `${newJobQueueTime.replace(/[^a-zA-Z0-9 ]/g, '')}-${randomInt(10 ** 9, 10 ** 10 - 1)}`; // append a random 10 digit number on the end of the date string
     const newJobExecution: JobExecution = {
-      type: `${PARTITION_KEYS.jobExecution}-${createParams.jobName}`,
+      type: `${ENTITY_TYPES.jobExecution}-${createParams.jobName}`,
       ecsTaskId: null,
       timeStarted: null,
       timeFinished: null,
       input: null,
+      retryCount: 0,
+      lastFailureReason: null,
+      retryAfter: null,
 
       id: newJobId,
       timeQueued: newJobQueueTime,
@@ -63,16 +65,7 @@ export class JobExecutionRepository extends Repository<JobExecution, JobExecutio
       ...createParams,
     };
 
-    const dynamoDbRecord = this.convertToDynamoDbItem(newJobExecution);
-
-    await this.dynamoDbClient.send(
-      new PutItemCommand({
-        Item: dynamoDbRecord,
-        TableName: this.tableName,
-      }),
-    );
-
-    return newJobExecution;
+    return this.create(newJobExecution);
   }
 
   /**
@@ -81,70 +74,66 @@ export class JobExecutionRepository extends Repository<JobExecution, JobExecutio
    * @returns {Promise<Array<JobExecution>>} The retrieved records.
    * @memberof JobExecutionRepository
    */
-  async list(parameters?: ListJobExecutionParameters): Promise<Array<JobExecution>> {
-    const expressionAttributeNames: Record<string, string> = {};
-    const expressionAttributeValues: Record<string, AttributeValue> = {};
-
-    const params = {
-      ExpressionAttributeNames: expressionAttributeNames,
-      ExpressionAttributeValues: expressionAttributeValues,
-      FilterExpression: '',
-      TableName: this.tableName,
-      ScanIndexForward: false,
+  async list(parameters: ListJobExecutionParameters = {}): Promise<Array<JobExecution>> {
+    let indexName: string | undefined = undefined;
+    const keyConditionExpressions = ['#pk = :pk'];
+    const expressionAttributeNames: Record<string, string> = {
+      '#pk': 'pk',
+    };
+    const expressionAttributeValues: Record<string, AttributeValue> = {
+      ':pk': { S: this.pk },
     };
 
-    if (!parameters || !parameters.jobName) {
-      params.ExpressionAttributeNames['#pk'] = 'pk';
-      params.ExpressionAttributeValues[':pkPrefix'] = { S: PARTITION_KEYS.jobExecution };
-      params.FilterExpression += `begins_with(#pk, :pkPrefix)`;
-    }
-
-    if (parameters) {
-      const { jobName, status } = parameters;
-
-      if (jobName) {
-        params.ExpressionAttributeNames['#pk'] = 'pk';
-        params.ExpressionAttributeValues[':pk'] = { S: `${PARTITION_KEYS.jobExecution}-${parameters.jobName}` };
-        params.FilterExpression += `#pk = :pk`;
-      }
-
-      if (status) {
-        // eslint-disable-next-line dot-notation
-        params.ExpressionAttributeNames['#status'] = 'status';
-        params.ExpressionAttributeValues[':status'] = { S: status };
-        params.FilterExpression += ` and #status = :status`;
+    if (parameters.filters) {
+      const { jobName, status } = parameters.filters;
+
+      if (jobName && status) {
+        indexName = 'lsi1';
+        expressionAttributeNames['#lsi1sk'] = 'lsi1sk';
+        expressionAttributeValues[':lsi1sk'] = { S: `${status}~${jobName}` };
+        keyConditionExpressions.push('#lsi1sk = :lsi1sk');
+      } else if (jobName) {
+        expressionAttributeNames['#sk'] = 'sk';
+        expressionAttributeValues[':skPrefix'] = { S: `${jobName}~` };
+        keyConditionExpressions.push('begins_with(#sk, :skPrefix)');
+      } else if (status) {
+        indexName = 'lsi1';
+        expressionAttributeNames['#lsi1sk'] = 'lsi1sk';
+        expressionAttributeValues[':lsi1skPrefix'] = { S: `${status}~` };
+        keyConditionExpressions.push('begins_with(#lsi1sk, :lsi1skPrefix)');
       }
     }
 
-    // Apply pagination for the scan.
-    // By default, the Scan operation processes data sequentially.
-    // DynamoDB returns data in increments of 1 MB increments.
-
-    let startKey; /* Indicator of where to paginate from. */
+    let startKey: Record<string, AttributeValue> | undefined = undefined; /* Indicator of where to paginate from. */
     const results: Array<Record<string, AttributeValue>> = [];
 
     // Iterate through pages until no more results are found.
-    while (startKey !== null) {
-      const res: ScanCommandOutput = await this.dynamoDbClient.send(
-        new ScanCommand({ ...params, ExclusiveStartKey: startKey }),
+    do {
+      const res: QueryCommandOutput = await this.dynamoDbClient.send(
+        new QueryCommand({
+          ExpressionAttributeNames: expressionAttributeNames,
+          ExpressionAttributeValues: expressionAttributeValues,
+          KeyConditionExpression: keyConditionExpressions.join(' and '),
+          IndexName: indexName,
+          TableName: this.tableName,
+          ScanIndexForward: false,
+          ExclusiveStartKey: startKey,
+          Limit: parameters.limit,
+          ConsistentRead: parameters.consistentRead,
+        }),
       );
 
-      if (!res) {
-        // Stop paginating if result is unexpected.
-        startKey = null;
-      } else {
-        results.push(
-          ...(res.Items ??
-            /* istanbul ignore next */
-            []),
-        );
-
-        // If no more results, set key to null to terminate loop
-        startKey = res.LastEvaluatedKey ?? null;
+      results.push(...(res?.Items || []));
+      startKey = res?.LastEvaluatedKey;
+
+      if (parameters.limit !== undefined && results.length >= parameters.limit) {
+        // Truncate list to max requested items, stop querying.
+        results.length = parameters.limit;
+        break;
       }
-    }
+    } while (startKey);
 
-    return results.length ? results.map((item) => this.convertToItem(item as JobExecutionDto)) : [];
+    return results.map((item) => this.convertToItem(item as JobExecutionDto));
   }
 
   /**
@@ -158,9 +147,10 @@ export class JobExecutionRepository extends Repository<JobExecution, JobExecutio
 
     const params: QueryCommandInput = {
       ExpressionAttributeValues: {
-        ':pk': { S: `${PARTITION_KEYS.jobExecution}-${jobName}` },
+        ':pk': { S: this.pk },
+        ':skPrefix': { S: `${jobName}~` },
       },
-      KeyConditionExpression: 'pk = :pk',
+      KeyConditionExpression: 'pk = :pk and begins_with(sk, :skPrefix)',
       TableName: this.tableName,
     };
 
@@ -186,55 +176,28 @@ export class JobExecutionRepository extends Repository<JobExecution, JobExecutio
     };
   }
 
-  /**
-   * Get one record from database.
-   * @abstract
-   * @param {string} sk The sort key used to identify the record.
-   * @returns {Promise<JobExecution | null>} The retrieved record.
-   * @memberof Repository
-   */
-  async findOne(sk: string, jobName?: string): Promise<JobExecution | null> {
-    if (!jobName) {
-      throw new InternalServerError('Job name is required');
-    }
-    const params: GetItemCommandInput = {
-      Key: {
-        pk: { S: parsePartitionKey(`${PARTITION_KEYS.jobExecution}-${jobName}`) },
-        sk: { S: sk },
-      },
-      TableName: this.tableName,
-    };
-    const res = await this.dynamoDbClient.send(new GetItemCommand(params));
-    return res.Item ? this.convertToItem(res.Item as JobExecutionDto) : null;
-  }
-
   /**
    * Update record in database.
    * @param {string} sk The sort key used to identify the record.
    * @param {Partial<JobExecution>} input The (partial) record to update.
-   * @param {string} jobName The name of the job used to identify the record as part of the pk.
    * @param {UpdateItemCommandInput} options Additional options for the update command.
    * @returns {Promise<JobExecution | null>} The updated record.
    * @memberof JobExecutionRepository
    */
   async update(
-    sk: string,
+    sk: JobExecutionSk,
     input: UpdateJobExecutionParameters,
-    jobName?: string,
     options?: {
       ConditionExpression?: string;
       ExpressionAttributeValues?: Record<string, AttributeValue>;
       ExpressionAttributeNames?: Record<string, string>;
     },
-  ): Promise<JobExecution | null> {
-    if (!jobName || jobName === '') {
-      throw new InternalServerError('Job name is required');
-    }
+  ): Promise<JobExecution> {
     // Initialise update command
     const updateParams: UpdateItemCommandInput = {
       Key: {
-        pk: { S: `${PARTITION_KEYS.jobExecution}-${jobName}` },
-        sk: { S: sk },
+        pk: { S: this.pk },
+        sk: { S: this.buildSk(sk) },
       },
       ReturnValues: 'ALL_NEW',
       TableName: this.tableName,
@@ -242,25 +205,36 @@ export class JobExecutionRepository extends Repository<JobExecution, JobExecutio
 
     const expressionAttributeNames: Record<string, string> = {};
     const expressionAttributeValues: Record<string, AttributeValue> = {};
+    const updateExpressionPairs: Array<string> = [];
 
     // To avoid conflict with reserved keywords, refer to attributes with an additional '#' prefix
     for (const key of Object.keys(input)) {
-      if (input[key as keyof UpdateJobExecutionParameters] === null) {
-        expressionAttributeNames[`#${key}`] = key;
+      const val = input[key as keyof UpdateJobExecutionParameters];
+      expressionAttributeNames[`#${key}`] = key;
+
+      if (val === null) {
         expressionAttributeValues[`:${key}`] = { NULL: true };
+      } else if (typeof val === 'number') {
+        expressionAttributeValues[`:${key}`] = { N: val.toString() };
       } else {
-        const val: string = input[key as keyof UpdateJobExecutionParameters] as string;
-        expressionAttributeNames[`#${key}`] = key;
-        expressionAttributeValues[`:${key}`] = { S: val };
+        expressionAttributeValues[`:${key}`] = { S: val as string };
       }
-    }
 
-    const updateExpressionPairs = Object.keys(input).map((key) => `#${key} = :${key}`);
-    const updateExpression = `SET ${updateExpressionPairs.join(', ')}`;
+      updateExpressionPairs.push(`#${key} = :${key}`);
+
+      if (key === 'status') {
+        expressionAttributeNames[`#lsi1sk`] = 'lsi1sk';
+        expressionAttributeValues[`:lsi1sk`] = { S: `${val || ''}~${sk.jobName}` };
+        expressionAttributeNames[`#gsi1pk`] = 'gsi1pk';
+        expressionAttributeValues[`:gsi1pk`] = { S: `${ENTITY_TYPES.jobExecution}~${val}` };
+        updateExpressionPairs.push(`#lsi1sk = :lsi1sk`);
+        updateExpressionPairs.push(`#gsi1pk = :gsi1pk`);
+      }
+    }
 
     updateParams.ExpressionAttributeNames = expressionAttributeNames;
     updateParams.ExpressionAttributeValues = expressionAttributeValues;
-    updateParams.UpdateExpression = updateExpression;
+    updateParams.UpdateExpression = `SET ${updateExpressionPairs.join(', ')}`;
 
     // Add condition expression if provided
     if (options?.ConditionExpression) {
@@ -286,7 +260,11 @@ export class JobExecutionRepository extends Repository<JobExecution, JobExecutio
     const updateItemCommand = new UpdateItemCommand(updateParams);
     const updatedRecord = await this.dynamoDbClient.send(updateItemCommand);
 
-    return updatedRecord.Attributes ? this.convertToItem(updatedRecord.Attributes as JobExecutionDto) : null;
+    return this.convertToItem(updatedRecord.Attributes as JobExecutionDto);
+  }
+
+  buildSk(sk: JobExecutionSk): string {
+    return `${sk.jobName}~${sk.id}`;
   }
 
   /* istanbul ignore next */
@@ -294,32 +272,25 @@ export class JobExecutionRepository extends Repository<JobExecution, JobExecutio
     return {
       context: { S: item.context },
       ecsTaskId: item.ecsTaskId ? { S: item.ecsTaskId } : { NULL: true },
+      gsi1pk: { S: `${ENTITY_TYPES.jobExecution}~${item.status}` },
       id: { S: item.id },
       jobName: { S: item.jobName },
-      pk: { S: item.type },
-      sk: { S: item.id },
+      lsi1sk: { S: `${item.status}~${item.jobName}` },
+      pk: { S: this.pk },
+      sk: { S: this.buildSk(item) },
       status: { S: item.status },
       timeFinished: item.timeFinished ? { S: item.timeFinished } : { NULL: true },
       timeQueued: { S: item.timeQueued },
       timeStarted: item.timeStarted ? { S: item.timeQueued } : { NULL: true },
       version: item.version ? { S: item.version } : { NULL: true },
       input: item.input ? { S: JSON.stringify(item.input) } : { NULL: true },
+      retryCount: { N: item.retryCount.toString() },
+      lastFailureReason: item.lastFailureReason ? { S: item.lastFailureReason } : { NULL: true },
+      retryAfter: item.retryAfter ? { S: item.retryAfter } : { NULL: true },
     };
   }
 
   convertToItem(dbItem: JobExecutionDto): JobExecution {
-    return {
-      context: dbItem.context.S as string,
-      ecsTaskId: dbItem.ecsTaskId.S ? (dbItem.ecsTaskId.S as string) : null,
-      id: dbItem.id.S as string,
-      jobName: dbItem.jobName.S as string,
-      status: dbItem.status.S as JOB_EXECUTION_STATUS,
-      timeFinished: dbItem.timeFinished.S ? (dbItem.timeFinished.S as string) : null,
-      timeQueued: dbItem.timeQueued.S as string,
-      timeStarted: dbItem.timeStarted.S ? (dbItem.timeStarted.S as string) : null,
-      type: parsePartitionKey(dbItem.pk.S as string) as JobExecutionPk,
-      version: dbItem.version.S as string,
-      input: dbItem.input?.S ? JSON.parse(dbItem.input.S) : null,
-    };
+    return convertDynamoDbItemToJobExecution(dbItem);
   }
 }

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

@@ -0,0 +1,22 @@
+import { JOB_EXECUTION_STATUS } from '../../../../constants/JobExecutionStatus.constants';
+import { JobExecution, JobExecutionDto } from '../../../../model/JobExecution';
+import { parsePartitionKey } from '../../../../ParsePartitionKey';
+
+export const convertDynamoDbItemToJobExecution = (dbItem: JobExecutionDto): JobExecution => {
+  return {
+    context: dbItem.context.S as string,
+    ecsTaskId: dbItem.ecsTaskId.S ? (dbItem.ecsTaskId.S as string) : null,
+    id: dbItem.id.S as string,
+    jobName: dbItem.jobName.S as string,
+    status: dbItem.status.S as JOB_EXECUTION_STATUS,
+    timeFinished: dbItem.timeFinished.S ? (dbItem.timeFinished.S as string) : null,
+    timeQueued: dbItem.timeQueued.S as string,
+    timeStarted: dbItem.timeStarted.S ? (dbItem.timeStarted.S as string) : null,
+    type: `${parsePartitionKey(dbItem.pk.S as string).entityType}-${dbItem.jobName.S}`,
+    version: dbItem.version.S as string,
+    input: dbItem.input?.S ? JSON.parse(dbItem.input.S) : null,
+    retryCount: dbItem.retryCount?.N ? parseInt(dbItem.retryCount.N, 10) : 0,
+    lastFailureReason: dbItem.lastFailureReason?.S ? (dbItem.lastFailureReason.S as string) : null,
+    retryAfter: dbItem.retryAfter?.S ? (dbItem.retryAfter.S as string) : null,
+  };
+};

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

@@ -0,0 +1 @@
+export * from './convertDynamoDbItemToJobExecution/convertDynamoDbItemToJobExecution';

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

@@ -12,22 +12,23 @@ import {
   ScanCommandOutput,
 } from '@aws-sdk/client-dynamodb';
 import { initIocContainer, iocContainer } from '../../../../mocks/mockIoc';
-import { testLogger } from '../../../../jest-global-setup';
 import {
   createMockClientPutResponse,
   createMockClientScanResponse,
   createMockClientGetResponse,
 } from '../../core/dynamoClient.mock';
-import { PARTITION_KEYS } from '../../constants/Repository.constants';
-import { JobManifest } from '../../manifest/JobManifestTypes';
-import { createMockJobManifest } from '../../manifest/mocks/JobManifest.mock';
-import { createMockJobManifestDto, createMockJobManifestDtos } from '../../manifest/mocks/JobManifestDto.mock';
-import { createMockJobManifestRecord } from '../../manifest/mocks/JobManifestRecord.mock';
-import { createMockCreateJobManifestRequest } from '../../manifest/mocks/JobManifestRequest.mock';
+import { ENTITY_TYPES } from '../../constants/Repository.constants';
+import {
+  JobManifest,
+  createMockJobManifest,
+  createMockJobManifestDto,
+  createMockJobManifestDtos,
+  createMockJobManifestRecord,
+  createMockCreateJobManifestRequest,
+} from '../../manifest';
 import { JobManifestRepository } from './JobManifestRepository';
 
-// Create a new container tsoa can use
-initIocContainer(testLogger);
+initIocContainer();
 
 // Mock DynamoDB Client
 const mockOptions = {} as DynamoDBClientConfig;
@@ -46,10 +47,6 @@ describe('JobManifestRepository', (): void => {
   });
 
   describe('find', () => {
-    beforeEach(() => {
-      jest.resetAllMocks();
-    });
-
     it(`should return an empty list`, async (): Promise<void> => {
       mockSend.mockImplementationOnce((): ScanCommandOutput => createMockClientScanResponse());
 
@@ -101,10 +98,6 @@ describe('JobManifestRepository', (): void => {
   });
 
   describe('findOne', () => {
-    beforeEach(() => {
-      jest.resetAllMocks();
-    });
-
     it(`should return job manifest`, async (): Promise<void> => {
       const mockJobManifestItem = createMockJobManifestDto();
       mockSend.mockImplementationOnce(
@@ -114,9 +107,10 @@ describe('JobManifestRepository', (): void => {
           }),
       );
 
-      const response = await jobManifestRepository.findOne(
-        `${mockJobManifestItem.name.S}-${mockJobManifestItem.version.S}` as string,
-      );
+      const response = await jobManifestRepository.findOne({
+        name: mockJobManifestItem.name.S as string,
+        version: mockJobManifestItem.version.S as string,
+      });
       expect(response).toStrictEqual({
         concurrency: parseInt(mockJobManifestItem.concurrency.N as string),
         entryFile: mockJobManifestItem.entryFile.S as string,
@@ -137,22 +131,18 @@ describe('JobManifestRepository', (): void => {
           }),
       );
 
-      const response = await jobManifestRepository.findOne(`null`);
+      const response = await jobManifestRepository.findOne({ name: 'null', version: '1.0.0' });
       expect(mockSend).toBeCalledTimes(1);
       expect(response).toBe(null);
     });
   });
 
   describe('create', () => {
-    beforeEach(() => {
-      jest.resetAllMocks();
-    });
-
     it(`should create a new job manifest record and return job manifest in the response`, async (): Promise<void> => {
       const newJobManifestToCreate = createMockCreateJobManifestRequest();
       const mockReponse = createMockClientPutResponse({
         Attributes: createMockJobManifestDto({
-          pk: PARTITION_KEYS.manifest,
+          pk: ENTITY_TYPES.manifest,
           sk: newJobManifestToCreate.name,
         }),
       });
@@ -163,16 +153,12 @@ describe('JobManifestRepository', (): void => {
       expect(mockSend).toBeCalledTimes(1);
       expect(response).toStrictEqual({
         ...newJobManifestToCreate,
-        type: PARTITION_KEYS.manifest,
+        type: ENTITY_TYPES.manifest,
       });
     });
   });
 
   describe('update', () => {
-    beforeEach(() => {
-      jest.resetAllMocks();
-    });
-
     it(`should update a job manifest record`, async (): Promise<void> => {
       const jobManifestToUpdate = createMockJobManifest();
       const updatedJobManifest: JobManifest = {
@@ -182,7 +168,7 @@ describe('JobManifestRepository', (): void => {
       };
       const updatedJobManifestRecord = createMockJobManifestRecord({
         ...updatedJobManifest,
-        sk: `${updatedJobManifest.name}-${updatedJobManifest.version}`,
+        sk: `${updatedJobManifest.name}~${updatedJobManifest.version}`,
       });
       const updatedJobManifestRecordDto = createMockJobManifestDto({
         ...updatedJobManifestRecord,
@@ -194,7 +180,10 @@ describe('JobManifestRepository', (): void => {
       mockSend.mockImplementation((): PutItemCommandOutput => putResponse);
 
       const response = await jobManifestRepository.update(
-        `${jobManifestToUpdate.name}-${jobManifestToUpdate.version}`,
+        {
+          name: jobManifestToUpdate.name,
+          version: jobManifestToUpdate.version,
+        },
         updatedJobManifestRecord,
       );
       expect(response).toStrictEqual(updatedJobManifest);
@@ -203,10 +192,6 @@ describe('JobManifestRepository', (): void => {
   });
 
   describe('delete', () => {
-    beforeEach(() => {
-      jest.resetAllMocks();
-    });
-
     it(`should return undefined when calling the delete operation`, async (): Promise<void> => {
       mockSend.mockImplementationOnce((): DeleteItemCommandOutput => {
         return {
@@ -214,7 +199,7 @@ describe('JobManifestRepository', (): void => {
         };
       });
 
-      const response = await jobManifestRepository.delete(`name`);
+      const response = await jobManifestRepository.delete({ name: `name`, version: '1.0.0' });
       expect(response).toBe(undefined);
       expect(mockSend).toBeCalledTimes(1);
     });