@squiz/job-runner-lib 1.66.1

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

@@ -0,0 +1,301 @@
+/*!
+ * @license
+ * Copyright Squiz Australia Pty Ltd. All Rights Reserved.
+ */
+
+import {
+  AttributeValue,
+  DeleteItemCommandOutput,
+  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 { JobContext } from '../../model/JobContext/JobContext';
+import { createMockJobContext } from '../../model/JobContext/mocks/JobContext.mock';
+import { createMockJobContextDto, createMockJobContextDtos } from '../../model/JobContext/mocks/JobContextDto.mock';
+import { createMockJobContextRecord } from '../../model/JobContext/mocks/JobContextRecord.mock';
+import { createMockCreateJobContextRequest } from '../../model/JobContext/mocks/JobContextRequest.mock';
+import { JobContextRepository } from './JobContextRepository';
+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 JobContextRepository with a mocked client
+iocContainer.rebind<DynamoDBClient>(DynamoDBClient).toConstantValue(mockClient);
+
+let jobContextRepository: JobContextRepository;
+
+describe('JobContextRepository', (): void => {
+  beforeAll(() => {
+    jobContextRepository = iocContainer.get(JobContextRepository);
+  });
+
+  describe('find', () => {
+    beforeEach(() => {
+      jest.resetAllMocks();
+    });
+
+    it(`should return an empty list`, async (): Promise<void> => {
+      mockSend.mockImplementationOnce((): ScanCommandOutput => createMockClientScanResponse());
+
+      const response = await jobContextRepository.list();
+      expect(mockSend).toBeCalled();
+      expect(response).toStrictEqual([]);
+    });
+
+    it(`should return a list of existing job context`, async (): Promise<void> => {
+      const mockContextItems = createMockJobContextDtos();
+
+      mockSend.mockImplementationOnce(
+        (): ScanCommandOutput =>
+          createMockClientScanResponse({
+            Items: mockContextItems,
+            LastEvaluatedKey: undefined,
+          }),
+      );
+
+      const response = await jobContextRepository.list();
+      expect(mockSend).toBeCalledTimes(1);
+      expect(response).toHaveLength(mockContextItems.length);
+    });
+
+    it(`should paginate results to return a list of existing job contexts`, async (): Promise<void> => {
+      const mockContextItemsPage1 = createMockJobContextDtos();
+      const mockContextItemsPage2 = createMockJobContextDtos();
+
+      mockSend
+        .mockImplementationOnce(
+          (): ScanCommandOutput =>
+            createMockClientScanResponse({
+              Items: mockContextItemsPage1,
+              LastEvaluatedKey: mockContextItemsPage1.slice(-1)[0],
+            }),
+        )
+        .mockImplementationOnce(
+          (): ScanCommandOutput =>
+            createMockClientScanResponse({
+              Items: mockContextItemsPage2,
+              LastEvaluatedKey: undefined,
+            }),
+        );
+
+      const response = await jobContextRepository.list();
+      expect(mockSend).toBeCalledTimes(2);
+      expect(response).toHaveLength(mockContextItemsPage1.length + mockContextItemsPage2.length);
+    });
+  });
+
+  describe('findOne', () => {
+    beforeEach(() => {
+      jest.resetAllMocks();
+    });
+
+    it(`should return job context by name`, async (): Promise<void> => {
+      const mockJobContextItem = createMockJobContextDto({
+        environment: { key: 'value' },
+      });
+      mockSend.mockImplementationOnce(
+        (): GetItemCommandOutput =>
+          createMockClientGetResponse({
+            Item: mockJobContextItem,
+          }),
+      );
+
+      const response = await jobContextRepository.findOne(mockJobContextItem.sk.S as string);
+      expect(response).toStrictEqual({
+        contextName: mockJobContextItem.sk.S as string,
+        description: mockJobContextItem.description.S as string,
+        environment: { key: 'value' },
+        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 jobContextRepository.findOne(`null`);
+      expect(mockSend).toBeCalledTimes(1);
+      expect(response).toBe(null);
+    });
+  });
+
+  describe('create', () => {
+    beforeEach(() => {
+      jest.resetAllMocks();
+    });
+
+    it(`should create a new job context record and return job context in the response`, async (): Promise<void> => {
+      const newJobContextToCreate = createMockCreateJobContextRequest();
+      const mockResponse = createMockClientPutResponse({
+        Attributes: createMockJobContextDto({
+          pk: PARTITION_KEYS.context,
+          sk: newJobContextToCreate.contextName,
+        }),
+      });
+
+      mockSend.mockImplementationOnce((): PutItemCommandOutput => mockResponse);
+
+      const response = await jobContextRepository.create(newJobContextToCreate);
+      expect(mockSend).toBeCalledTimes(1);
+      expect(response).toStrictEqual({
+        ...newJobContextToCreate,
+        type: PARTITION_KEYS.context,
+      });
+    });
+  });
+
+  describe('update', () => {
+    beforeEach(() => {
+      jest.resetAllMocks();
+    });
+
+    it(`should update a job context record`, async (): Promise<void> => {
+      const jobContextToUpdate = createMockJobContext();
+      const updatedJobContext: JobContext = {
+        ...jobContextToUpdate,
+        contextName: `new-name`,
+        description: `this is description`,
+        environment: { name: 'Bob', age: '35' },
+      };
+      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 jobContextRepository.update(jobContextToUpdate.contextName, updatedJobContextRecord);
+      expect(response).toStrictEqual(updatedJobContext);
+      expect(mockSend).toBeCalledTimes(1);
+    });
+  });
+
+  describe('delete', () => {
+    beforeEach(() => {
+      jest.resetAllMocks();
+    });
+
+    it(`should return undefined when calling the delete operation`, async (): Promise<void> => {
+      mockSend.mockImplementationOnce((): DeleteItemCommandOutput => {
+        return {
+          $metadata: {},
+        };
+      });
+
+      const response = await jobContextRepository.delete(`name`);
+      expect(response).toBe(undefined);
+      expect(mockSend).toBeCalledTimes(1);
+    });
+  });
+
+  describe('getContexts', () => {
+    let mockExclusiveStartKey: Record<string, AttributeValue>;
+    let mockPaginationInfo: PaginationInfo;
+    let mockParams: QueryCommandInput;
+
+    beforeEach(() => {
+      mockExclusiveStartKey = {
+        pk: { S: PARTITION_KEYS.context },
+        sk: { S: 'mockSk' },
+      };
+      mockPaginationInfo = {
+        direction: PAGINATION_DIRECTION_TYPE_BEFORE,
+        limit: 100,
+        requestUrl: 'mockUrl',
+        token: 'mockToken',
+      };
+      mockParams = {
+        ExclusiveStartKey: mockExclusiveStartKey,
+        ExpressionAttributeValues: {
+          ':pk': { S: PARTITION_KEYS.context },
+        },
+        KeyConditionExpression: 'pk = :pk',
+        ScanIndexForward: false,
+        TableName: process.env.DYNAMODB_TABLE,
+      };
+
+      jest.spyOn(PaginationUtils, 'decodeTokenString').mockReturnValue(mockExclusiveStartKey);
+    });
+
+    it('should return an empty array if no contexts are found', async () => {
+      mockSend.mockImplementationOnce(() =>
+        Promise.resolve({
+          Items: [],
+          LastEvaluatedKey: null,
+        }),
+      );
+
+      const mockRequestData: PaginationInfo = mockPaginationInfo;
+
+      const result = await jobContextRepository.getContexts(mockRequestData);
+
+      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 mockJobContextRecords = createMockJobContextDtos();
+      const mockLastEvaluatedKey = {
+        pk: { S: PARTITION_KEYS.job },
+        sk: { S: 'mockSk' },
+      };
+
+      mockSend.mockImplementationOnce(() =>
+        Promise.resolve({
+          Items: mockJobContextRecords,
+          LastEvaluatedKey: mockLastEvaluatedKey,
+        }),
+      );
+
+      const mockRequestData: PaginationInfo = mockPaginationInfo;
+
+      const result = await jobContextRepository.getContexts(mockRequestData);
+
+      expect(mockSend).toHaveBeenCalledWith(
+        expect.objectContaining({
+          input: { ...mockParams },
+        }),
+      );
+      expect(result.items).toHaveLength(mockJobContextRecords.length);
+      expect(result.lastEvaluatedKey).toStrictEqual(mockLastEvaluatedKey);
+    });
+  });
+});

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

@@ -0,0 +1,168 @@
+/*!
+ * @license
+ * Copyright Squiz Australia Pty Ltd. All Rights Reserved.
+ */
+
+import * as dotenv from 'dotenv';
+dotenv.config();
+
+import {
+  AttributeValue,
+  DynamoDBClient,
+  PutItemCommand,
+  QueryCommand,
+  QueryCommandInput,
+  UpdateItemCommand,
+  UpdateItemCommandInput,
+} from '@aws-sdk/client-dynamodb';
+import { inject } from 'inversify';
+import { provideTransient } from '../../transientProvider';
+import { Repository } from '../AbstractRepository';
+import { PARTITION_KEYS } from '../../constants/Repository.constants';
+import { parsePartitionKey } from '../../ParsePartitionKey';
+import { CreateJobContextRequest, JobContext, JobContextDto } from '../../model/JobContext/JobContext';
+import { PaginationInfo } from '../../core/pagination/model/PaginationInfo';
+import { PaginationQueryResponse } from '../../core/pagination/model/PaginationQueryResponse';
+import { decodeTokenString } from '../../core/pagination/utils/PaginationUtils';
+import { PAGINATION_DIRECTION_TYPE_BEFORE } from '../../core/pagination/model/PaginationTypes';
+
+@provideTransient(JobContextRepository)
+export class JobContextRepository extends Repository<JobContext, JobContextDto> {
+  public constructor(@inject(DynamoDBClient) protected dynamoDbClient: DynamoDBClient) {
+    super(dynamoDbClient);
+    this.pk = PARTITION_KEYS.context;
+    this.tableName = process.env.DYNAMODB_TABLE as string;
+  }
+
+  public async create(input: CreateJobContextRequest): Promise<JobContext> {
+    const newJobContext: JobContext = {
+      ...input,
+      type: this.pk,
+    };
+
+    const dynamoDbRecord = this.convertToDynamoDbItem(newJobContext);
+
+    await this.dynamoDbClient.send(
+      new PutItemCommand({
+        Item: dynamoDbRecord,
+        TableName: this.tableName,
+      }),
+    );
+
+    return newJobContext;
+  }
+
+  /**
+   * Get list of records from database.
+   * @abstract
+   * @returns {Promise<Array<T>>} The retrieved records.
+   * @memberof Repository
+   */
+  async getContexts(paginationInfo: PaginationInfo): Promise<PaginationQueryResponse<JobContext>> {
+    const { token, direction } = paginationInfo;
+
+    const params: QueryCommandInput = {
+      ExpressionAttributeValues: {
+        ':pk': { S: this.pk },
+      },
+      KeyConditionExpression: 'pk = :pk',
+      TableName: this.tableName,
+    };
+
+    if (token) {
+      params.ExclusiveStartKey = decodeTokenString(token);
+    }
+
+    if (direction === PAGINATION_DIRECTION_TYPE_BEFORE) {
+      params.ScanIndexForward = false;
+    }
+
+    const response = await this.dynamoDbClient.send(new QueryCommand(params));
+
+    let items: Array<JobContext> = [];
+    if (response.Items && response.Items.length) {
+      items = response.Items.map((item) => this.convertToItem(item as JobContextDto));
+    }
+
+    return {
+      items,
+      lastEvaluatedKey: response.LastEvaluatedKey,
+    };
+  }
+
+  async update(sk: string, input: Partial<JobContext>): Promise<JobContext | null> {
+    // Initialise update command
+    const updateParams: UpdateItemCommandInput = {
+      Key: {
+        pk: { S: this.pk },
+        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
+    const environmentMap: Record<string, any> = {};
+    if (input.environment) {
+      for (const key of Object.keys(input.environment)) {
+        environmentMap[key] = { S: input.environment[key] };
+      }
+      expressionAttributeNames['#environment'] = 'environment';
+      expressionAttributeValues[':environment'] = { M: environmentMap };
+    }
+    if (input.description != null) {
+      expressionAttributeNames['#description'] = 'description';
+      expressionAttributeValues[':description'] = { S: input.description };
+    }
+
+    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 updatedJob = await this.dynamoDbClient.send(updateItemCommand);
+
+    /* istanbul ignore next */
+    return updatedJob.Attributes ? this.convertToItem(updatedJob.Attributes as JobContextDto) : null;
+  }
+
+  convertToDynamoDbItem(item: JobContext): JobContextDto {
+    const environmentMap: Record<string, any> = {};
+    for (const key of Object.keys(item.environment)) {
+      environmentMap[key] = { S: item.environment[key] };
+    }
+
+    return {
+      pk: { S: item.type },
+      sk: { S: item.contextName },
+      description: { S: item.description },
+      environment: { M: environmentMap },
+    };
+  }
+
+  convertToItem(dbItem: JobContextDto): JobContext {
+    const { pk, sk, description } = dbItem;
+
+    const environment = dbItem.environment as AttributeValue.MMember;
+    const environmentMap = environment.M;
+
+    const environmentRecord: Record<string, any> = {};
+
+    for (const key of Object.keys(environmentMap)) {
+      environmentRecord[key] = environmentMap[key].S;
+    }
+
+    return {
+      contextName: sk.S as string,
+      type: parsePartitionKey(pk.S as string),
+      description: description.S as string,
+      environment: environmentRecord,
+    };
+  }
+}