@squiz/job-runner-lib 1.66.1

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

@@ -0,0 +1,371 @@
+/*!
+ * @license
+ * Copyright Squiz Australia Pty Ltd. All Rights Reserved.
+ */
+
+import {
+  AttributeValue,
+  DynamoDBClient,
+  DynamoDBClientConfig,
+  GetItemCommandOutput,
+  PutItemCommandOutput,
+  QueryCommandInput,
+  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 { JOB_EXECUTION_STATUS } from '../../constants/JobExecutionStatus.constants';
+import { JobExecution } from '../../model/JobExecution/JobExecution';
+import { createMockJobExecution } from '../../model/JobExecution/mocks/JobExecution.mock';
+import {
+  createMockJobExecutionDto,
+  createMockJobExecutionDtos,
+} from '../../model/JobExecution/mocks/JobExecutionDto.mock';
+import { JobExecutionRepository } from './JobExecutionRepository';
+import * as PaginationUtils from '../../core/pagination/utils/PaginationUtils';
+import { PaginationInfo } from '../../core/pagination/model/PaginationInfo';
+import { PAGINATION_DIRECTION_TYPE_BEFORE } from '../../core/pagination/model/PaginationTypes';
+
+// Create a new container tsoa can use
+initIocContainer(testLogger);
+
+// Mock DynamoDB Client
+const mockOptions = {} as DynamoDBClientConfig;
+const mockClient = new DynamoDBClient(mockOptions);
+const mockSend = jest.fn();
+mockClient.send = mockSend;
+
+// Inject JobRepository with a mocked client
+iocContainer.rebind<DynamoDBClient>(DynamoDBClient).toConstantValue(mockClient);
+
+let jobExecutionRepository: JobExecutionRepository;
+
+describe('JobExecutionRepository', (): void => {
+  beforeAll(() => {
+    jobExecutionRepository = iocContainer.get(JobExecutionRepository);
+  });
+
+  describe('list', () => {
+    beforeEach(() => {
+      jest.resetAllMocks();
+    });
+
+    it(`should return an empty list`, async (): Promise<void> => {
+      mockSend.mockImplementationOnce((): ScanCommandOutput => createMockClientScanResponse());
+
+      const response = await jobExecutionRepository.list({ jobName: 'does-not-exist' });
+      expect(mockSend).toBeCalled();
+      expect(response).toStrictEqual([]);
+    });
+
+    it(`should return a list of existing job executions`, async (): Promise<void> => {
+      const mockRecord = createMockJobExecutionDto();
+
+      mockSend.mockImplementationOnce(
+        (): ScanCommandOutput =>
+          createMockClientScanResponse({
+            Items: [mockRecord],
+            LastEvaluatedKey: undefined,
+          }),
+      );
+
+      const response = await jobExecutionRepository.list();
+      expect(mockSend).toBeCalledTimes(1);
+      expect(response).toHaveLength(1);
+    });
+
+    it(`should return a list of existing job executions by name`, async (): Promise<void> => {
+      const mockName = `mock`;
+      const mockRecords = [
+        createMockJobExecutionDto({ jobName: mockName }),
+        createMockJobExecutionDto({ jobName: mockName }),
+      ];
+
+      mockSend.mockImplementationOnce(
+        (): ScanCommandOutput =>
+          createMockClientScanResponse({
+            Items: mockRecords,
+            LastEvaluatedKey: undefined,
+          }),
+      );
+
+      const response = await jobExecutionRepository.list({ jobName: mockName });
+      expect(mockSend).toBeCalledTimes(1);
+      expect(response).toHaveLength(mockRecords.length);
+    });
+
+    it(`should return a list of existing job executions by status`, async (): Promise<void> => {
+      const mockStatus = JOB_EXECUTION_STATUS.running;
+      const mockRecords = [
+        createMockJobExecutionDto({ status: mockStatus }),
+        createMockJobExecutionDto({ status: mockStatus }),
+      ];
+
+      mockSend.mockImplementationOnce(
+        (): ScanCommandOutput =>
+          createMockClientScanResponse({
+            Items: mockRecords,
+            LastEvaluatedKey: undefined,
+          }),
+      );
+
+      const response = await jobExecutionRepository.list({ status: mockStatus });
+      expect(mockSend).toBeCalledTimes(1);
+      expect(response).toHaveLength(mockRecords.length);
+    });
+
+    it(`should paginate results to return a list of existing job executions`, async (): Promise<void> => {
+      const mockRecordsPage1 = [
+        createMockJobExecutionDto({ jobName: 'testJob1' }),
+        createMockJobExecutionDto({ jobName: 'testJob1' }),
+        createMockJobExecutionDto({ jobName: 'testJob1' }),
+      ];
+      const mockRecordsPage2 = [
+        createMockJobExecutionDto({ jobName: 'testJob2' }),
+        createMockJobExecutionDto({ jobName: 'testJob2' }),
+        createMockJobExecutionDto({ jobName: 'testJob2' }),
+      ];
+
+      mockSend
+        .mockImplementationOnce(
+          (): ScanCommandOutput =>
+            createMockClientScanResponse({
+              Items: mockRecordsPage1,
+              LastEvaluatedKey: mockRecordsPage1.slice(-1)[0],
+            }),
+        )
+        .mockImplementationOnce(
+          (): ScanCommandOutput =>
+            createMockClientScanResponse({
+              Items: mockRecordsPage2,
+              LastEvaluatedKey: undefined,
+            }),
+        );
+
+      const response = await jobExecutionRepository.list({ jobName: 'testJob1' });
+      expect(mockSend).toBeCalledTimes(2);
+      expect(response).toHaveLength(mockRecordsPage1.length + mockRecordsPage2.length);
+    });
+
+    it(`should stop paginating if unexpected result is returned`, async (): Promise<void> => {
+      mockSend.mockImplementationOnce(() => null);
+
+      const response = await jobExecutionRepository.list({ jobName: 'testJob1' });
+      expect(mockSend).toBeCalledTimes(1);
+      expect(response).toHaveLength(0);
+    });
+  });
+
+  describe('findOne', () => {
+    beforeEach(() => {
+      jest.resetAllMocks();
+    });
+
+    it(`should return job execution by timeQueued and id and handle any null values`, async (): Promise<void> => {
+      const mockJobExecutionRecord = createMockJobExecutionDto({
+        ecsTaskId: 'ecs-task-id',
+        timeFinished: new Date().toISOString(),
+        timeStarted: new Date().toISOString(),
+        version: '1.0.0',
+      });
+
+      mockSend.mockImplementationOnce(
+        (): GetItemCommandOutput =>
+          createMockClientGetResponse({
+            Item: mockJobExecutionRecord,
+          }),
+      );
+
+      const response = await jobExecutionRepository.findOne(
+        `${mockJobExecutionRecord.timeQueued.S as string}-${mockJobExecutionRecord.id.S as string}`,
+        mockJobExecutionRecord.jobName.S as string,
+      );
+      expect(response).toStrictEqual({
+        context: mockJobExecutionRecord.context.S as string,
+        ecsTaskId: mockJobExecutionRecord.ecsTaskId.NULL ? null : (mockJobExecutionRecord.ecsTaskId.S as string),
+        id: mockJobExecutionRecord.id.S as string,
+        jobName: mockJobExecutionRecord.jobName.S as string,
+        status: mockJobExecutionRecord.status.S as string,
+        timeFinished: mockJobExecutionRecord.timeFinished.NULL
+          ? null
+          : (mockJobExecutionRecord.timeFinished.S as string),
+        timeQueued: mockJobExecutionRecord.timeQueued.S as string,
+        timeStarted: mockJobExecutionRecord.timeStarted.NULL ? null : (mockJobExecutionRecord.timeStarted.S as string),
+        type: `jobExecution-${mockJobExecutionRecord.jobName.S as string}`,
+        version: mockJobExecutionRecord.version.NULL ? null : (mockJobExecutionRecord.version.S as string),
+        input: mockJobExecutionRecord.input.NULL ? null : JSON.parse(mockJobExecutionRecord.input.S as string),
+      } as JobExecution);
+      expect(mockSend).toBeCalledTimes(1);
+    });
+
+    it(`should return null if job execution does not exist`, async (): Promise<void> => {
+      mockSend.mockImplementationOnce(
+        (): ScanCommandOutput =>
+          createMockClientScanResponse({
+            Items: [],
+          }),
+      );
+
+      const response = await jobExecutionRepository.findOne(`null`, `null`);
+      expect(mockSend).toBeCalledTimes(1);
+      expect(response).toBe(null);
+    });
+  });
+
+  describe('create', () => {
+    beforeEach(() => {
+      jest.resetAllMocks();
+    });
+
+    it(`should create a new job execution record and return job execution record in the response`, async (): Promise<void> => {
+      const newJobExecutionToCreate = createMockJobExecution();
+      const mockResponse = createMockClientPutResponse({
+        Attributes: {
+          jobName: { S: newJobExecutionToCreate.jobName },
+          pk: { S: PARTITION_KEYS.jobExecution },
+          sk: { S: `${newJobExecutionToCreate.jobName}` },
+        },
+      });
+
+      mockSend.mockImplementationOnce((): PutItemCommandOutput => mockResponse);
+
+      const response = await jobExecutionRepository.create(newJobExecutionToCreate);
+      expect(mockSend).toBeCalledTimes(1);
+      expect(response).toStrictEqual({
+        ...newJobExecutionToCreate,
+      });
+    });
+  });
+
+  describe('begin', () => {
+    beforeEach(() => {
+      jest.resetAllMocks();
+    });
+
+    it(`should create a new queued job record`, async (): Promise<void> => {
+      const newJobExecutionToCreate = createMockJobExecution({
+        status: JOB_EXECUTION_STATUS.queued,
+        ecsTaskId: null,
+        timeFinished: null,
+        timeStarted: null,
+      });
+      const mockReponse = createMockClientPutResponse({
+        Attributes: {
+          pk: { S: `${PARTITION_KEYS.jobExecution}-${newJobExecutionToCreate.jobName}` },
+          sk: { S: `${newJobExecutionToCreate.timeQueued}-${newJobExecutionToCreate.id}` },
+          name: { S: newJobExecutionToCreate.jobName },
+          context: { S: newJobExecutionToCreate.context },
+          version: { S: newJobExecutionToCreate.version },
+          ecsTaskId: { NULL: true },
+          timeStarted: { NULL: true },
+          timeFinished: { NULL: true },
+        },
+      });
+
+      mockSend.mockImplementationOnce(() => Promise.resolve(mockReponse));
+
+      const response = await jobExecutionRepository.begin({
+        context: newJobExecutionToCreate.context,
+        jobName: newJobExecutionToCreate.jobName,
+        version: newJobExecutionToCreate.version,
+        input: newJobExecutionToCreate.input,
+      });
+      expect(mockSend).toBeCalledTimes(1);
+      expect(response.id).not.toBeNull();
+      expect(response.timeQueued).not.toBeNull();
+      expect(response.ecsTaskId).toBeNull();
+      expect(response.timeFinished).toBeNull();
+      expect(response.timeStarted).toBeNull();
+      expect(response.type).toBe(`jobExecution-${newJobExecutionToCreate.jobName}`);
+      expect(response.jobName).toBe(newJobExecutionToCreate.jobName);
+      expect(response.version).toBe(newJobExecutionToCreate.version);
+      expect(response.input).toBe(newJobExecutionToCreate.input);
+    });
+  });
+
+  describe('getExecutions', () => {
+    let mockExclusiveStartKey: Record<string, AttributeValue>;
+    let mockPaginationInfo: PaginationInfo;
+    let mockParams: QueryCommandInput;
+
+    beforeEach(() => {
+      mockExclusiveStartKey = {
+        pk: { S: `${PARTITION_KEYS.jobExecution}-something` },
+        sk: { S: 'mockSk' },
+      };
+      mockPaginationInfo = {
+        direction: PAGINATION_DIRECTION_TYPE_BEFORE,
+        limit: 100,
+        requestUrl: 'mockUrl',
+        token: 'mockToken',
+      };
+      mockParams = {
+        ExclusiveStartKey: mockExclusiveStartKey,
+        ExpressionAttributeValues: {
+          ':pk': { S: `${PARTITION_KEYS.jobExecution}-something` },
+        },
+        KeyConditionExpression: 'pk = :pk',
+        TableName: process.env.DYNAMODB_TABLE,
+      };
+
+      jest.spyOn(PaginationUtils, 'decodeTokenString').mockReturnValue(mockExclusiveStartKey);
+    });
+
+    it('should return an empty array if no executions are found', async () => {
+      mockSend.mockImplementationOnce(() =>
+        Promise.resolve({
+          Items: [],
+          LastEvaluatedKey: null,
+        }),
+      );
+
+      const mockRequestData: PaginationInfo = mockPaginationInfo;
+
+      const result = await jobExecutionRepository.getExecutions(mockRequestData, 'something');
+
+      expect(mockSend).toHaveBeenCalledWith(
+        expect.objectContaining({
+          input: { ...mockParams },
+        }),
+      );
+      expect(result.items).toEqual([]);
+      expect(result.lastEvaluatedKey).toBe(null);
+    });
+
+    it('should return an array of jobs if found', async () => {
+      const mockJobExecutionRecords = createMockJobExecutionDtos();
+      const mockLastEvaluatedKey = {
+        pk: { S: `${PARTITION_KEYS.job}-${'something'}` },
+        sk: { S: 'mockSk' },
+      };
+
+      mockSend.mockImplementationOnce(() =>
+        Promise.resolve({
+          Items: mockJobExecutionRecords,
+          LastEvaluatedKey: mockLastEvaluatedKey,
+        }),
+      );
+
+      const mockRequestData: PaginationInfo = mockPaginationInfo;
+
+      const result = await jobExecutionRepository.getExecutions(
+        mockRequestData,
+        mockJobExecutionRecords[0].jobName.S as string,
+      );
+
+      expect(mockSend).toHaveBeenCalledWith(
+        expect.objectContaining({
+          input: { ...mockParams },
+        }),
+      );
+      expect(result.items).toHaveLength(mockJobExecutionRecords.length);
+      expect(result.lastEvaluatedKey).toStrictEqual(mockLastEvaluatedKey);
+    });
+  });
+});

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

@@ -0,0 +1,293 @@
+/*!
+ * @license
+ * Copyright Squiz Australia Pty Ltd. All Rights Reserved.
+ */
+
+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,
+  PutItemCommand,
+  QueryCommand,
+  QueryCommandInput,
+  ScanCommand,
+  ScanCommandOutput,
+  UpdateItemCommandInput,
+  UpdateItemCommand,
+} from '@aws-sdk/client-dynamodb';
+import { randomInt } from 'crypto';
+import { provideTransient } from '../../transientProvider';
+import { Repository } from '../AbstractRepository';
+import { parsePartitionKey } from '../../ParsePartitionKey';
+import {
+  CreateJobExecutionRequest,
+  JobExecution,
+  JobExecutionDto,
+  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';
+
+@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;
+  }
+
+  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}`,
+      ecsTaskId: null,
+      timeStarted: null,
+      timeFinished: null,
+      input: null,
+
+      id: newJobId,
+      timeQueued: newJobQueueTime,
+      status: JOB_EXECUTION_STATUS.queued,
+
+      ...createParams,
+    };
+
+    const dynamoDbRecord = this.convertToDynamoDbItem(newJobExecution);
+
+    await this.dynamoDbClient.send(
+      new PutItemCommand({
+        Item: dynamoDbRecord,
+        TableName: this.tableName,
+      }),
+    );
+
+    return newJobExecution;
+  }
+
+  /**
+   * Get list of records from database.
+   * @abstract
+   * @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,
+    };
+
+    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`;
+      }
+    }
+
+    // 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. */
+    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 }),
+      );
+
+      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;
+      }
+    }
+
+    return results.length ? results.map((item) => this.convertToItem(item as JobExecutionDto)) : [];
+  }
+
+  /**
+   * Get list of records from database.
+   * @abstract
+   * @returns {Promise<Array<T>>} The retrieved records.
+   * @memberof Repository
+   */
+  async getExecutions(paginationInfo: PaginationInfo, jobName: string): Promise<PaginationQueryResponse<JobExecution>> {
+    const { token, direction } = paginationInfo;
+
+    const params: QueryCommandInput = {
+      ExpressionAttributeValues: {
+        ':pk': { S: `${PARTITION_KEYS.jobExecution}-${jobName}` },
+      },
+      KeyConditionExpression: 'pk = :pk',
+      TableName: this.tableName,
+    };
+
+    if (token) {
+      params.ExclusiveStartKey = decodeTokenString(token);
+    }
+
+    // Executions are sorted in descending order.
+    if (direction === PAGINATION_DIRECTION_TYPE_AFTER) {
+      params.ScanIndexForward = false;
+    }
+
+    const response = await this.dynamoDbClient.send(new QueryCommand(params));
+
+    let items: Array<JobExecution> = [];
+    if (response.Items && response.Items.length) {
+      items = response.Items.map((item) => this.convertToItem(item as JobExecutionDto));
+    }
+
+    return {
+      items,
+      lastEvaluatedKey: response.LastEvaluatedKey,
+    };
+  }
+
+  /**
+   * 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.
+   * @returns {Promise<JobExecution | null>} The updated record.
+   * @memberof JobExecutionRepository
+   */
+  async update(sk: string, input: UpdateJobExecutionParameters, jobName?: string): Promise<JobExecution | null> {
+    if (!jobName || jobName === '') {
+      throw new InternalServerError('Job name is required');
+    }
+    // Initialise update command
+    const updateParams: UpdateItemCommandInput = {
+      Key: {
+        pk: { S: `${PARTITION_KEYS.jobExecution}-${jobName}` },
+        sk: { S: sk },
+      },
+      ReturnValues: 'ALL_NEW',
+      TableName: this.tableName,
+    };
+
+    const expressionAttributeNames: Record<string, string> = {};
+    const expressionAttributeValues: Record<string, AttributeValue> = {};
+
+    // 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;
+        expressionAttributeValues[`:${key}`] = { NULL: true };
+      } else {
+        const val: string = input[key as keyof UpdateJobExecutionParameters] as string;
+        expressionAttributeNames[`#${key}`] = key;
+        expressionAttributeValues[`:${key}`] = { S: val };
+      }
+    }
+
+    const updateExpressionPairs = Object.keys(input).map((key) => `#${key} = :${key}`);
+    const updateExpression = `SET ${updateExpressionPairs.join(', ')}`;
+
+    updateParams.ExpressionAttributeNames = expressionAttributeNames;
+    updateParams.ExpressionAttributeValues = expressionAttributeValues;
+    updateParams.UpdateExpression = updateExpression;
+
+    const updateItemCommand = new UpdateItemCommand(updateParams);
+    const updatedRecord = await this.dynamoDbClient.send(updateItemCommand);
+
+    return updatedRecord.Attributes ? this.convertToItem(updatedRecord.Attributes as JobExecutionDto) : null;
+  }
+
+  /* istanbul ignore next */
+  convertToDynamoDbItem(item: JobExecution): JobExecutionDto {
+    return {
+      context: { S: item.context },
+      ecsTaskId: item.ecsTaskId ? { S: item.ecsTaskId } : { NULL: true },
+      id: { S: item.id },
+      jobName: { S: item.jobName },
+      pk: { S: item.type },
+      sk: { S: item.id },
+      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 },
+    };
+  }
+
+  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,
+    };
+  }
+}