@squiz/job-runner-lib 1.66.2 → 2.1.0

package/src/domains/job/core/pagination/services/PaginationService.ts

@@ -4,20 +4,13 @@
  */
 
 import 'reflect-metadata';
-import { inject } from 'inversify';
 import { provideSingleton } from '../../../singletonProvider';
 import { BaseItem, BaseDto } from '../../../model/Base/Base';
-import { JobRepository } from '../../../repository/JobRepository/JobRepository';
-import { PARTITION_KEYS } from '../../../constants/Repository.constants';
 import { PaginationInfo } from '../model/PaginationInfo';
 import { PaginationTokens } from '../model/PaginationLinks';
 import { PaginationResponse } from '../model/PaginationResponse';
 import { PAGINATION_DIRECTION_TYPE_BEFORE } from '../model/PaginationTypes';
 import { encodeTokenString, getPaginationLinks } from '../utils/PaginationUtils';
-import { InternalServerError } from '../../../errors/InternalServerError';
-import { ERROR_MESSAGES } from '../../../errors/Error.constants';
-import { JobContextRepository } from '../../../repository/JobContextRepository/JobContextRepository';
-import { JobExecutionRepository } from '../../../repository/JobExecutionRepository/JobExecutionRepository';
 
 /**
  * Helper service to handle pagination.
@@ -27,20 +20,15 @@ import { JobExecutionRepository } from '../../../repository/JobExecutionReposito
  */
 @provideSingleton(PaginationService)
 export class PaginationService<T extends BaseItem> {
-  constructor(
-    @inject(JobRepository) protected jobRepository: JobRepository,
-    @inject(JobContextRepository) protected jobContextRepository: JobContextRepository,
-    @inject(JobExecutionRepository) protected jobExecutionRepository: JobExecutionRepository,
-  ) {}
-
   public addPaginationLinksToResponse(
     data: Array<T>,
     paginationInfo: PaginationInfo,
     lastEvaluatedKey: string | null,
+    convertToDynamoDbItem: (item: T) => BaseDto,
   ): PaginationResponse<T> {
     const { direction, limit, requestUrl } = paginationInfo;
 
-    const paginationTokens = this.getPaginationTokens(data, paginationInfo, lastEvaluatedKey);
+    const paginationTokens = this.getPaginationTokens(data, paginationInfo, lastEvaluatedKey, convertToDynamoDbItem);
     const links = getPaginationLinks(requestUrl, paginationTokens);
     data = data.slice(0, limit);
 
@@ -55,6 +43,7 @@ export class PaginationService<T extends BaseItem> {
     data: Array<T>,
     paginationInfo: PaginationInfo,
     lastEvaluatedKey: string | null,
+    convertToDynamoDbItem: (item: T) => BaseDto,
   ): PaginationTokens {
     const { token, direction, limit } = paginationInfo;
 
@@ -62,14 +51,14 @@ export class PaginationService<T extends BaseItem> {
     let lastItemToken: string | null = null;
 
     if (token || direction === PAGINATION_DIRECTION_TYPE_BEFORE) {
-      firstItemToken = this.getTokenForFirstData(data);
+      firstItemToken = this.getTokenForDto(convertToDynamoDbItem(data[0]));
     }
 
     if (data.length <= limit) {
       lastItemToken = lastEvaluatedKey;
     } else {
       data = data.slice(0, limit);
-      lastItemToken = this.getTokenForLastData(data);
+      lastItemToken = this.getTokenForDto(convertToDynamoDbItem(data[data.length - 1]));
     }
 
     let nextToken = lastItemToken;
@@ -88,36 +77,12 @@ export class PaginationService<T extends BaseItem> {
 
   /**
    * Get the encoded token for the first item of the data array.
-   * @param {Array<T>} data The array of items.
-   * @returns {string} The token string.
-   * @memberof Repository
-   */
-  protected getTokenForFirstData(data: Array<T>): string {
-    const firstData = data[0];
-    const firstDynamoItem = this.convertToDynamoDbItem(firstData);
-
-    const { pk, sk } = firstDynamoItem;
-
-    const primaryKey = {
-      pk,
-      sk,
-    };
-
-    return encodeTokenString(primaryKey);
-  }
-
-  /**
-   * Get the encoded token for last item of the data array.
-   * @param {Array<T>} data The array of items.
+   * @param {BaseDto} dto The array of items.
    * @returns {string} The token string.
    * @memberof Repository
    */
-  protected getTokenForLastData(data: Array<T>): string {
-    const lastData = data[data.length - 1];
-    const lastDynamoItem = this.convertToDynamoDbItem(lastData);
-
-    const { pk, sk } = lastDynamoItem;
-
+  protected getTokenForDto(dto: BaseDto): string {
+    const { pk, sk } = dto;
     const primaryKey = {
       pk,
       sk,
@@ -125,18 +90,4 @@ export class PaginationService<T extends BaseItem> {
 
     return encodeTokenString(primaryKey);
   }
-
-  protected convertToDynamoDbItem = (item: any): BaseDto => {
-    if (item.type.startsWith(PARTITION_KEYS.jobExecution)) {
-      return this.jobExecutionRepository.convertToDynamoDbItem(item);
-    }
-    switch (item.type) {
-      case PARTITION_KEYS.job:
-        return this.jobRepository.convertToDynamoDbItem(item);
-      case PARTITION_KEYS.context:
-        return this.jobContextRepository.convertToDynamoDbItem(item);
-      default:
-        throw new InternalServerError(ERROR_MESSAGES.primaryKeyInvalidPK);
-    }
-  };
 }

package/src/domains/job/index.ts

@@ -11,6 +11,7 @@ export * from './model/Job';
 export * from './model/JobContext';
 export * from './model/JobExecution';
 export * from './model/Base';
+export * from './model/LogPayload';
 
 export * from './errors';
 export * from './manifest';
@@ -19,3 +20,4 @@ export * from './ParsePartitionKey';
 export * from './transientProvider';
 export * from './singletonProvider';
 export * from './repository';
+export * from './S3Repository';

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

@@ -1,5 +1,4 @@
-import { JobManifestV1Model } from '../../../domains/manifest/ManifestModel';
-import { SchemaVersions } from '../../../domains/manifest/AbstractManifest';
+import { JobManifestV1Model, SchemaVersions } from '../../../domains/manifest/ManifestModel';
 import { ResourceNotFoundError } from '@squiz/dx-common-lib';
 import { MANIFEST_MODELS } from '@squiz/dx-json-schema-lib';
 import path from 'path';

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

@@ -0,0 +1,12 @@
+export type LogPayload = {
+  message: string;
+  type?: string;
+  area?: string;
+  req_id?: string;
+  'log-command'?: string;
+  level?: string;
+  'function-name'?: string;
+  'job-name'?: string;
+  'job-version'?: string;
+  timestamp: string;
+};

package/src/domains/job/model/LogPayload/index.ts

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

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

@@ -13,7 +13,7 @@ import {
   QueryCommandInput,
   ScanCommandOutput,
 } from '@aws-sdk/client-dynamodb';
-import { initIocContainer, iocContainer } from '../mocks/mockIoc';
+import { initIocContainer, iocContainer } from '../../../../mocks/mockIoc';
 import { testLogger } from '../../../../jest-global-setup';
 import {
   createMockClientPutResponse,

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

@@ -12,7 +12,7 @@ import {
   QueryCommandInput,
   ScanCommandOutput,
 } from '@aws-sdk/client-dynamodb';
-import { initIocContainer, iocContainer } from '../mocks/mockIoc';
+import { initIocContainer, iocContainer } from '../../../../mocks/mockIoc';
 import { testLogger } from '../../../../jest-global-setup';
 import {
   createMockClientPutResponse,
@@ -354,10 +354,7 @@ describe('JobExecutionRepository', (): void => {
 
       const mockRequestData: PaginationInfo = mockPaginationInfo;
 
-      const result = await jobExecutionRepository.getExecutions(
-        mockRequestData,
-        mockJobExecutionRecords[0].jobName.S as string,
-      );
+      const result = await jobExecutionRepository.getExecutions(mockRequestData, 'something');
 
       expect(mockSend).toHaveBeenCalledWith(
         expect.objectContaining({

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

@@ -6,24 +6,29 @@
 import * as dotenv from 'dotenv';
 dotenv.config();
 
-import { inject } from 'inversify';
-import { JOB_EXECUTION_STATUS } from '../../constants/JobExecutionStatus.constants';
-import { JobExecutionPk, PARTITION_KEYS } from '../../constants/Repository.constants';
 import {
   AttributeValue,
   DynamoDBClient,
+  GetItemCommand,
+  GetItemCommandInput,
   PutItemCommand,
   QueryCommand,
   QueryCommandInput,
   ScanCommand,
   ScanCommandOutput,
-  UpdateItemCommandInput,
   UpdateItemCommand,
+  UpdateItemCommandInput,
 } from '@aws-sdk/client-dynamodb';
 import { randomInt } from 'crypto';
-import { provideTransient } from '../../transientProvider';
-import { Repository } from '../AbstractRepository';
+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 {
   CreateJobExecutionRequest,
   JobExecution,
@@ -31,12 +36,8 @@ import {
   ListJobExecutionParameters,
   UpdateJobExecutionParameters,
 } from '../../model/JobExecution/JobExecution';
-import { PaginationInfo } from '../../core/pagination/model/PaginationInfo';
-import { PaginationQueryResponse } from '../../core/pagination/model/PaginationQueryResponse';
-import { decodeTokenString } from '../../core/pagination/utils/PaginationUtils';
-import { InternalServerError } from '../../errors';
-import { GetItemCommandInput, GetItemCommand } from '@aws-sdk/client-dynamodb';
-import { PAGINATION_DIRECTION_TYPE_AFTER } from '../../core/pagination/model/PaginationTypes';
+import { provideTransient } from '../../transientProvider';
+import { Repository } from '../AbstractRepository';
 
 @provideTransient(JobExecutionRepository)
 export class JobExecutionRepository extends Repository<JobExecution, JobExecutionDto> {
@@ -212,10 +213,20 @@ export class JobExecutionRepository extends Repository<JobExecution, JobExecutio
    * @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, input: UpdateJobExecutionParameters, jobName?: string): Promise<JobExecution | null> {
+  async update(
+    sk: string,
+    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');
     }
@@ -251,6 +262,27 @@ export class JobExecutionRepository extends Repository<JobExecution, JobExecutio
     updateParams.ExpressionAttributeValues = expressionAttributeValues;
     updateParams.UpdateExpression = updateExpression;
 
+    // Add condition expression if provided
+    if (options?.ConditionExpression) {
+      updateParams.ConditionExpression = options.ConditionExpression;
+    }
+
+    if (options?.ExpressionAttributeValues) {
+      // Merge existing expression attribute values with the ones from options
+      updateParams.ExpressionAttributeValues = {
+        ...updateParams.ExpressionAttributeValues,
+        ...options.ExpressionAttributeValues,
+      };
+    }
+
+    // Add expression attribute names if provided
+    if (options?.ExpressionAttributeNames) {
+      updateParams.ExpressionAttributeNames = {
+        ...updateParams.ExpressionAttributeNames,
+        ...options.ExpressionAttributeNames,
+      };
+    }
+
     const updateItemCommand = new UpdateItemCommand(updateParams);
     const updatedRecord = await this.dynamoDbClient.send(updateItemCommand);
 

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

@@ -11,7 +11,7 @@ import {
   PutItemCommandOutput,
   ScanCommandOutput,
 } from '@aws-sdk/client-dynamodb';
-import { initIocContainer, iocContainer } from '../mocks/mockIoc';
+import { initIocContainer, iocContainer } from '../../../../mocks/mockIoc';
 import { testLogger } from '../../../../jest-global-setup';
 import {
   createMockClientPutResponse,

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

@@ -12,7 +12,7 @@ import {
   QueryCommandInput,
   ScanCommandOutput,
 } from '@aws-sdk/client-dynamodb';
-import { initIocContainer, iocContainer } from '../mocks/mockIoc';
+import { initIocContainer, iocContainer } from '../../../../mocks/mockIoc';
 import { testLogger } from '../../../../jest-global-setup';
 import {
   createMockClientPutResponse,

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

@@ -0,0 +1,272 @@
+/*!
+ * @license
+ * Copyright Squiz Australia Pty Ltd. All Rights Reserved.
+ */
+import {
+  AttributeValue,
+  DeleteItemCommandOutput,
+  DynamoDBClient,
+  DynamoDBClientConfig,
+  GetItemCommandOutput,
+  PutItemCommandOutput,
+  ScanCommandOutput,
+} from '@aws-sdk/client-dynamodb';
+
+import * as PaginationUtils from '../../core/pagination/utils/PaginationUtils';
+import { faker } from '@faker-js/faker/locale/en';
+import { JobContextService } from './JobContextService';
+import { PAGINATION_DIRECTION_TYPE_AFTER, PaginationService } from '../../core/pagination';
+import { JobContextRepository } from '../../repository';
+import {
+  createMockCreateJobContextRequest,
+  createMockJobContext,
+  createMockJobContextDto,
+  createMockJobContextDtos,
+  createMockJobContextRecord,
+  createMockJobContexts,
+  JobContext,
+} from '../../model/JobContext';
+import {
+  createMockClientGetResponse,
+  createMockClientPutResponse,
+  createMockClientScanResponse,
+} from '../../core/dynamoClient.mock';
+import { PARTITION_KEYS } from '../../constants/Repository.constants';
+
+// Mock DynamoDB Client
+const mockOptions = {} as DynamoDBClientConfig;
+const mockClient = new DynamoDBClient(mockOptions);
+
+const mockSend = jest.fn();
+mockClient.send = mockSend;
+
+let jobContextService: JobContextService;
+let paginationService: PaginationService<any>;
+describe('JobContextService', (): void => {
+  beforeAll((): void => {
+    const jobContextRepository = new JobContextRepository(mockClient);
+    paginationService = new PaginationService();
+    jobContextService = new JobContextService(jobContextRepository, paginationService);
+  });
+
+  describe(`createJobContext`, (): void => {
+    beforeEach(() => {
+      jest.resetAllMocks();
+    });
+
+    it(`should return a response for createJobContext`, async (): Promise<void> => {
+      const newJobContextToCreate = createMockCreateJobContextRequest();
+      const environmentMap: Record<string, AttributeValue> = {};
+      for (const key of Object.keys(newJobContextToCreate.environment)) {
+        environmentMap[key] = { S: newJobContextToCreate.environment[key] };
+      }
+      const mockResponse = createMockClientPutResponse({
+        Attributes: {
+          pk: { S: PARTITION_KEYS.context },
+          sk: { S: newJobContextToCreate.contextName },
+          name: { S: newJobContextToCreate.contextName },
+          version: { M: environmentMap },
+        },
+      });
+
+      mockSend.mockImplementationOnce((): PutItemCommandOutput => mockResponse);
+
+      const response = await jobContextService.createJobContext(newJobContextToCreate);
+      expect(mockSend).toBeCalledTimes(1);
+      expect(response).toStrictEqual({
+        ...newJobContextToCreate,
+        type: PARTITION_KEYS.context,
+      });
+    });
+  });
+
+  describe(`deleteJobContext`, (): void => {
+    beforeEach(() => {
+      jest.resetAllMocks();
+    });
+
+    it(`should return an empty response for job context deletion`, async (): Promise<void> => {
+      mockSend.mockImplementationOnce((): DeleteItemCommandOutput => {
+        return {
+          $metadata: {},
+        };
+      });
+
+      const response = await jobContextService.deleteJobContext(`name`);
+      expect(response).toBe(undefined);
+      expect(mockSend).toBeCalledTimes(1);
+    });
+  });
+
+  describe(`findJobContext`, (): void => {
+    beforeEach(() => {
+      jest.resetAllMocks();
+    });
+
+    it(`should return job context by name`, async (): Promise<void> => {
+      const mockJobContextRecord = createMockJobContextDto({
+        environment: { key: 'value' },
+      });
+
+      mockSend.mockImplementationOnce(
+        (): GetItemCommandOutput =>
+          createMockClientGetResponse({
+            Item: mockJobContextRecord,
+          }),
+      );
+
+      const response = await jobContextService.findJobContext(mockJobContextRecord.sk.S as string);
+      expect(response).toStrictEqual({
+        contextName: mockJobContextRecord.sk.S as string,
+        environment: { key: 'value' },
+        description: mockJobContextRecord.description.S as string,
+        type: `context`,
+      } as JobContext);
+      expect(mockSend).toBeCalledTimes(1);
+    });
+
+    it(`should return null if job context does not exist`, async (): Promise<void> => {
+      mockSend.mockImplementationOnce(
+        (): ScanCommandOutput =>
+          createMockClientScanResponse({
+            Items: [],
+          }),
+      );
+
+      const response = await jobContextService.findJobContext(`null`);
+      expect(mockSend).toBeCalledTimes(1);
+      expect(response).toBe(null);
+    });
+  });
+
+  describe(`listAllJobContexts`, (): void => {
+    beforeEach(() => {
+      jest.resetAllMocks();
+    });
+
+    it(`should return an empty list`, async (): Promise<void> => {
+      mockSend.mockImplementationOnce((): ScanCommandOutput => createMockClientScanResponse());
+
+      const response = await jobContextService.listAllJobContexts();
+      expect(mockSend).toBeCalled();
+      expect(response).toStrictEqual([]);
+    });
+
+    it(`should return a list of existing job contexts`, async (): Promise<void> => {
+      const mockRecords = createMockJobContextDtos();
+
+      mockSend.mockImplementationOnce(
+        (): ScanCommandOutput =>
+          createMockClientScanResponse({
+            Items: mockRecords,
+            LastEvaluatedKey: undefined,
+          }),
+      );
+
+      const response = await jobContextService.listAllJobContexts();
+      expect(mockSend).toBeCalledTimes(1);
+      expect(response).toHaveLength(mockRecords.length);
+    });
+
+    it(`should paginate results to return a list of existing job context`, async (): Promise<void> => {
+      const mockRecordsPage1 = createMockJobContextDtos();
+      const mockRecordsPage2 = createMockJobContextDtos();
+
+      mockSend
+        .mockImplementationOnce(
+          (): ScanCommandOutput =>
+            createMockClientScanResponse({
+              Items: mockRecordsPage1,
+              LastEvaluatedKey: mockRecordsPage1.slice(-1)[0],
+            }),
+        )
+        .mockImplementationOnce(
+          (): ScanCommandOutput =>
+            createMockClientScanResponse({
+              Items: mockRecordsPage2,
+              LastEvaluatedKey: undefined,
+            }),
+        );
+
+      const response = await jobContextService.listAllJobContexts();
+      expect(mockSend).toBeCalledTimes(2);
+      expect(response).toHaveLength(mockRecordsPage1.length + mockRecordsPage2.length);
+    });
+  });
+
+  describe(`listJobContexts`, (): void => {
+    let mockJobContexts: Array<JobContext>;
+    let mockPaginationInfo: any;
+    let mockPaginationLinks: any;
+    let mockRequestData: any;
+    let getContextsSpy: any;
+
+    beforeEach(() => {
+      jest.resetAllMocks();
+
+      mockJobContexts = createMockJobContexts();
+
+      mockPaginationInfo = {
+        direction: PAGINATION_DIRECTION_TYPE_AFTER,
+        limit: 100,
+        requestUrl: faker.internet.url(),
+        token: null,
+      };
+      mockPaginationLinks = {
+        next: null,
+        prev: null,
+      };
+      mockRequestData = { mockPaginationInfo };
+
+      getContextsSpy = jest.spyOn(JobContextRepository.prototype, 'getContexts');
+      getContextsSpy.mockResolvedValue({
+        items: mockJobContexts,
+        lastEvaluatedKey: undefined,
+      });
+
+      jest.spyOn(PaginationUtils, 'getPaginationLinks').mockReturnValue(mockPaginationLinks);
+    });
+
+    it(`should return all contexts if there are less than the specified limit`, async (): Promise<void> => {
+      const result = await jobContextService.listJobContexts(mockRequestData);
+      expect(result).toStrictEqual({ data: mockJobContexts });
+      expect(getContextsSpy).toHaveBeenCalledWith(mockRequestData);
+    });
+  });
+
+  describe(`updateJobContext`, (): void => {
+    beforeEach(() => {
+      jest.resetAllMocks();
+    });
+
+    it(`should update a job context record`, async (): Promise<void> => {
+      const jobContextToUpdate = createMockJobContext();
+      const updatedJobContext: JobContext = {
+        ...jobContextToUpdate,
+        environment: { name: 'Alice', age: '30' },
+        contextName: `new-name`,
+        description: `this is description`,
+      };
+      const updatedJobContextRecord = createMockJobContextRecord({
+        sk: updatedJobContext.contextName,
+        environment: updatedJobContext.environment,
+        description: updatedJobContext.description,
+      });
+      const updatedJobContextRecordDto = createMockJobContextDto({
+        ...updatedJobContextRecord,
+      });
+      const putResponse = createMockClientPutResponse({
+        Attributes: { ...updatedJobContextRecordDto },
+      });
+
+      mockSend.mockImplementation((): PutItemCommandOutput => putResponse);
+
+      const response = await jobContextService.updateJobContext(
+        jobContextToUpdate.contextName,
+        updatedJobContextRecord,
+      );
+      expect(response).toStrictEqual(updatedJobContext);
+      expect(mockSend).toBeCalledTimes(1);
+    });
+  });
+});

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

@@ -0,0 +1,77 @@
+/*!
+ * @license
+ * Copyright Squiz Australia Pty Ltd. All Rights Reserved.
+ */
+
+import { inject } from 'inversify';
+import { JobContextRepository } from '../../repository';
+import { provideSingleton } from '../../singletonProvider';
+import {
+  encodeTokenString,
+  getFormattedResponse,
+  PaginationFormattedResponse,
+  PaginationInfo,
+  PaginationKey,
+  PaginationResponse,
+  PaginationService,
+} from '../../core/pagination';
+import { CreateJobContextRequest, JobContext, JobContextDto, UpdateJobContextRequest } from '../../model/JobContext';
+
+@provideSingleton(JobContextService)
+export class JobContextService {
+  constructor(
+    @inject(JobContextRepository) protected jobContextRepository: JobContextRepository,
+    @inject(PaginationService) protected paginationService: PaginationService<JobContext>,
+  ) {}
+
+  public async createJobContext(input: CreateJobContextRequest): Promise<JobContext> {
+    return this.jobContextRepository.create(input);
+  }
+
+  public async updateJobContext(name: string, input: UpdateJobContextRequest): Promise<JobContext | null> {
+    return this.jobContextRepository.update(name, input);
+  }
+
+  public async listAllJobContexts(): Promise<Array<JobContext>> {
+    return this.jobContextRepository.list();
+  }
+
+  public async listJobContexts(paginationInfo: PaginationInfo): Promise<PaginationFormattedResponse<JobContext>> {
+    const { links, data } = await this.listContextsUpToLimit(paginationInfo);
+
+    return getFormattedResponse<JobContext>({ links, data });
+  }
+
+  private async listContextsUpToLimit(paginationInfo: PaginationInfo): Promise<PaginationResponse<JobContext>> {
+    const { limit, token } = paginationInfo;
+
+    let currentToken = token;
+    const contexts: Array<JobContext> = [];
+
+    do {
+      const newRequestData = {
+        ...paginationInfo,
+        token: currentToken,
+      };
+
+      const { items, lastEvaluatedKey } = await this.jobContextRepository.getContexts(newRequestData);
+
+      contexts.push(...items);
+      currentToken = lastEvaluatedKey
+        ? encodeTokenString(lastEvaluatedKey as unknown as PaginationKey<JobContextDto>)
+        : null;
+    } while (currentToken && contexts.length < limit);
+
+    return this.paginationService.addPaginationLinksToResponse(contexts, paginationInfo, currentToken, (context) =>
+      this.jobContextRepository.convertToDynamoDbItem(context),
+    );
+  }
+
+  public async findJobContext(contextName: string): Promise<JobContext | null> {
+    return this.jobContextRepository.findOne(contextName);
+  }
+
+  public async deleteJobContext(contextName: string): Promise<void> {
+    return await this.jobContextRepository.delete(contextName);
+  }
+}