@squiz/job-runner-lib 2.2.0 → 2.4.0

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

@@ -3,39 +3,56 @@
  * Copyright Squiz Australia Pty Ltd. All Rights Reserved.
  */
 
-import { DesiredStatus, ECSClient, LaunchType, ListTasksCommand, RunTaskCommand } from '@aws-sdk/client-ecs';
-import { getAwsTags } from '../../utils';
-import { ListRunningTasksParams, RunJobTaskParams } from './JobExecutionTaskService.defs';
-import { JobDetailsRepository, S3Repository } from '../../S3Repository';
+import { ConflictException, ECSClient, LaunchType, RunTaskCommand } from '@aws-sdk/client-ecs';
+import { createHash } from 'node:crypto';
+import { JobDetailsRepository, JobUploadsRepository } from '../../S3Repository';
+import { JOB_EXECUTION_STATUS } from '../../constants/JobExecutionStatus.constants';
 import { JobExecution } from '../../model/JobExecution';
-import { JobManifestService } from '../JobManifestService/JobManifestService';
+import { JobExecutionRepository } from '../../repository';
+import { getAwsTags } from '../../utils';
 import { JobContextService } from '../JobContextService/JobContextService';
+import { JobManifestService } from '../JobManifestService/JobManifestService';
+import { HasReachedMaxTenantConcurrencyParams, RunJobTaskParams } from './JobExecutionTaskService.defs';
 
 export class JobExecutionTaskService {
   constructor(
     private readonly ecsClient: ECSClient,
     private readonly jobManifestService: JobManifestService,
     private readonly jobContextService: JobContextService,
+    private readonly jobExecutionRepository: JobExecutionRepository,
     private readonly jobDetailsRepository: JobDetailsRepository,
-    private readonly jobUploadRepository: S3Repository,
+    private readonly jobUploadRepository: JobUploadsRepository,
   ) {}
 
-  protected async getTenantRunningTasks(params: ListRunningTasksParams): Promise<number> {
-    const input = {
-      cluster: params.clusterArn,
-      family: params.runtimeTaskFamily,
-      maxResults: params.maxTenantConcurrentTasks + 1,
-      desiredStatus: DesiredStatus.RUNNING,
-    };
-    const command = new ListTasksCommand(input);
-    const response = await this.ecsClient.send(command);
-    return response.taskArns?.length ?? 0;
+  public async hasReachedMaxTenantConcurrency(params: HasReachedMaxTenantConcurrencyParams): Promise<boolean> {
+    const currentRunningExecutions = await this.jobExecutionRepository.list({
+      consistentRead: true,
+      limit: params.maxTenantConcurrentTasks,
+      filters: {
+        status: JOB_EXECUTION_STATUS.running,
+      },
+    });
+
+    return currentRunningExecutions.length >= params.maxTenantConcurrentTasks;
   }
 
-  public async hasReachedMaxTenantConcurrency(params: ListRunningTasksParams): Promise<boolean> {
-    const currentRunningTasks = await this.getTenantRunningTasks(params);
+  public async hasReachedMaxJobConcurrency(jobExecution: JobExecution): Promise<boolean> {
+    const jobManifest = await this.jobManifestService.findJobManifest(jobExecution.jobName, jobExecution.version);
+
+    if (!jobManifest || typeof jobManifest.concurrency !== 'number') {
+      return false;
+    }
+
+    const runningExecutions = await this.jobExecutionRepository.list({
+      consistentRead: true,
+      limit: jobManifest.concurrency,
+      filters: {
+        jobName: jobExecution.jobName,
+        status: JOB_EXECUTION_STATUS.running,
+      },
+    });
 
-    return currentRunningTasks > params.maxTenantConcurrentTasks;
+    return runningExecutions.length >= jobManifest.concurrency;
   }
 
   public async runJobExecutionTask(params: RunJobTaskParams): Promise<string | undefined> {
@@ -74,7 +91,7 @@ export class JobExecutionTaskService {
       {
         name: 'JOB_CODE_ARTIFACT_URL',
         value: await this.jobUploadRepository.getS3SignedUrl(
-          `${params.jobExecution.jobName}/${params.jobExecution.version}/export.zip`,
+          `${params.tenantId}/${params.jobExecution.jobName}/${params.jobExecution.version}/export.zip`,
         ),
       },
       {
@@ -83,49 +100,84 @@ export class JobExecutionTaskService {
       },
     ];
 
-    const result = await this.ecsClient.send(
-      new RunTaskCommand({
-        cluster: params.clusterArn,
-        networkConfiguration: {
-          awsvpcConfiguration: {
-            subnets: params.subnets,
-          },
-        },
-        launchType: LaunchType.FARGATE,
-        taskDefinition: params.taskDefinitionArn,
-        overrides: {
-          containerOverrides: [
-            {
-              name: 'job-runtime-container',
-              environment: environmentVariables,
+    try {
+      const result = await this.ecsClient.send(
+        new RunTaskCommand({
+          cluster: params.clusterArn,
+          networkConfiguration: {
+            awsvpcConfiguration: {
+              subnets: params.subnets,
             },
-          ],
-        },
-        tags: [
-          ...Object.entries(tags).map(([key, value]) => ({
+          },
+          launchType: LaunchType.FARGATE,
+          taskDefinition: params.taskDefinitionArn,
+          overrides: {
+            containerOverrides: [
+              {
+                name: 'job-runtime-container',
+                environment: environmentVariables,
+              },
+            ],
+          },
+          tags: Object.entries(tags).map(([key, value]) => ({
             key,
             value,
           })),
-        ],
-      }),
-    );
+          clientToken: this.computeJobExecutionClientToken(params),
+        }),
+      );
 
-    // This task ARN can be used to terminate the job task.
-    // If no error is returned, assume task has started.
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    const task = result.tasks![0];
-    return task.taskArn;
+      // This task ARN can be used to terminate the job task.
+      // If no error is returned, assume task has started.
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      const task = result.tasks![0];
+      return task.taskArn;
+    } catch (error) {
+      // Task already started with the provided "clientToken", return the previously started task ARN.
+      if (error instanceof ConflictException) {
+        if (error.resourceIds?.[0]) {
+          console.warn(
+            `Execution already started, returning previous task ARN: ${error.resourceIds[0]} ` +
+              `(id: "${params.jobExecution.id}", job: ${params.jobExecution.jobName}, tenant: ${params.tenantId})`,
+          );
+          return error.resourceIds[0];
+        } else {
+          // In some instances the previous task ARN isn't returned.
+          console.warn(
+            `Execution already started, no previous task ARN returned ` +
+              `(id: "${params.jobExecution.id}", job: ${params.jobExecution.jobName}, tenant: ${params.tenantId})`,
+          );
+          return undefined;
+        }
+      }
+
+      throw error;
+    }
+  }
+
+  private computeJobExecutionClientToken(params: RunJobTaskParams): string {
+    // https://docs.aws.amazon.com/AmazonECS/latest/APIReference/ECS_Idempotency.html#RunTaskIdempotency
+    // Include retryCount so that retry attempts get a unique clientToken and create new tasks
+    // Without this, ECS would return the old failed task ARN instead of creating a new task
+    const retryCount = params.jobExecution.retryCount ?? 0;
+    const key = `jobExecution~${params.tenantId}~${params.jobExecution.jobName}~${params.jobExecution.id}~${retryCount}`;
+
+    return createHash('sha1').update(key).digest('hex');
   }
 
   private async createJobDetailsFile(tenantId: string, executionToStart: JobExecution): Promise<string> {
-    const jobDetailsFileName = JobDetailsRepository.createJobDetailsFileName(tenantId, executionToStart.id);
     const jobManifest = await this.jobManifestService.findJobManifest(
       executionToStart.jobName,
       executionToStart.version,
     );
     const jobContext = await this.jobContextService.findJobContext(executionToStart.context);
 
-    await this.jobDetailsRepository.createJobDetailsFile(jobDetailsFileName, jobContext, jobManifest, executionToStart);
+    const jobDetailsFileName = await this.jobDetailsRepository.createJobDetailsFile(
+      tenantId,
+      jobContext,
+      jobManifest,
+      executionToStart,
+    );
     return await this.jobDetailsRepository.getS3SignedUrl(jobDetailsFileName);
   }
 }

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

@@ -4,14 +4,12 @@
  */
 import { initIocContainer, iocContainer } from '../../../../mocks/mockIoc';
 import {
-  DeleteItemCommandOutput,
   DynamoDBClient,
   DynamoDBClientConfig,
   GetItemCommandOutput,
   PutItemCommandOutput,
   ScanCommandOutput,
 } from '@aws-sdk/client-dynamodb';
-import { testLogger } from '../../../../jest-global-setup';
 import { JobManifestService } from './JobManifestService';
 import {
   createMockCreateJobManifestRequest,
@@ -26,10 +24,9 @@ import {
   createMockClientPutResponse,
   createMockClientScanResponse,
 } from '../../core/dynamoClient.mock';
-import { PARTITION_KEYS } from '../../constants/Repository.constants';
+import { ENTITY_TYPES } from '../../constants/Repository.constants';
 
-// Create a new container tsoa can use
-initIocContainer(testLogger);
+initIocContainer();
 
 // Mock DynamoDB Client
 const mockOptions = {} as DynamoDBClientConfig;
@@ -49,15 +46,11 @@ describe('JobManifestService', (): void => {
   });
 
   describe(`createJobManifest`, (): void => {
-    beforeEach(() => {
-      jest.resetAllMocks();
-    });
-
     it(`should return a response for createJob`, async (): Promise<void> => {
       const newJobManifestToCreate = createMockCreateJobManifestRequest();
       const mockReponse = createMockClientPutResponse({
         Attributes: createMockJobManifestDto({
-          pk: PARTITION_KEYS.manifest,
+          pk: ENTITY_TYPES.manifest,
           sk: newJobManifestToCreate.name,
         }),
       });
@@ -68,34 +61,12 @@ describe('JobManifestService', (): void => {
       expect(mockSend).toBeCalledTimes(1);
       expect(response).toStrictEqual({
         ...newJobManifestToCreate,
-        type: PARTITION_KEYS.manifest,
-      });
-    });
-  });
-
-  describe(`deleteJobManifest`, (): void => {
-    beforeEach(() => {
-      jest.resetAllMocks();
-    });
-
-    it(`should return an empty response for job manifest deletion`, async (): Promise<void> => {
-      mockSend.mockImplementationOnce((): DeleteItemCommandOutput => {
-        return {
-          $metadata: {},
-        };
+        type: ENTITY_TYPES.manifest,
       });
-
-      const response = await jobManifestService.deleteJobManifest(`name`);
-      expect(response).toBe(undefined);
-      expect(mockSend).toBeCalledTimes(1);
     });
   });
 
   describe(`findJobManifest`, (): void => {
-    beforeEach(() => {
-      jest.resetAllMocks();
-    });
-
     it(`should return job manifest`, async (): Promise<void> => {
       const mockJobManifestItem = createMockJobManifestDto();
       mockSend.mockImplementationOnce(
@@ -136,10 +107,6 @@ describe('JobManifestService', (): void => {
   });
 
   describe(`listAllJobManifests`, (): void => {
-    beforeEach(() => {
-      jest.resetAllMocks();
-    });
-
     it(`should return an empty list`, async (): Promise<void> => {
       mockSend.mockImplementationOnce((): ScanCommandOutput => createMockClientScanResponse());
 
@@ -191,10 +158,6 @@ describe('JobManifestService', (): void => {
   });
 
   describe(`updateJobManifest`, (): void => {
-    beforeEach(() => {
-      jest.resetAllMocks();
-    });
-
     it(`should update a job manifest record`, async (): Promise<void> => {
       const jobManifestToUpdate = createMockJobManifest({
         name: `name`,

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

@@ -21,8 +21,7 @@ export class JobManifestService {
     version: string,
     input: UpdateJobManifestRequest,
   ): Promise<JobManifest | null> {
-    const sk = `${name}-${version}`;
-    return this.jobManifestRepository.update(sk, input);
+    return this.jobManifestRepository.update({ name, version }, input);
   }
 
   public async listAllJobManifests(): Promise<Array<JobManifest>> {
@@ -30,11 +29,6 @@ export class JobManifestService {
   }
 
   public async findJobManifest(name: string, version: string): Promise<JobManifest | null> {
-    const sk = `${name}-${version}`;
-    return this.jobManifestRepository.findOne(sk);
-  }
-
-  public async deleteJobManifest(name: string): Promise<void> {
-    return await this.jobManifestRepository.delete(name);
+    return this.jobManifestRepository.findOne({ name, version });
   }
 }

package/src/domains/job/services/JobStartQueueService/JobStartQueueService.defs.ts

@@ -0,0 +1,27 @@
+/*!
+ * @license
+ * Copyright Squiz Australia Pty Ltd. All Rights Reserved.
+ */
+
+/**
+ * Message body for the job start queue.
+ */
+export interface JobStartMessage {
+  /** The tenant ID */
+  tenantId: string;
+  /** The job execution ID to start */
+  executionId: string;
+  /** The job name */
+  jobName: string;
+}
+
+/**
+ * Parameters for sending a job start message.
+ */
+export interface SendJobStartMessageParams {
+  tenantId: string;
+  executionId: string;
+  jobName: string;
+  /** Delay in seconds before the message becomes visible (0-900, max 15 minutes) */
+  delaySeconds?: number;
+}

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

@@ -0,0 +1,42 @@
+/*!
+ * @license
+ * Copyright Squiz Australia Pty Ltd. All Rights Reserved.
+ */
+
+import { SQSClient, SendMessageCommand } from '@aws-sdk/client-sqs';
+import { inject, injectable } from 'inversify';
+import { InjectTokens } from '../../constants/InjectTokens';
+import { JobStartMessage, SendJobStartMessageParams } from './JobStartQueueService.defs';
+
+@injectable()
+export class JobStartQueueService {
+  public constructor(
+    @inject(SQSClient) private readonly sqsClient: SQSClient,
+    @inject(InjectTokens.JobStartQueueUrl) private readonly queueUrl: string,
+  ) {}
+
+  /**
+   * Sends a job start message to the SQS queue.
+   * Uses a standard queue (not FIFO) to support DelaySeconds for retry backoff.
+   * Duplicate job starts are prevented by ECS RunTask clientToken.
+   */
+  public async sendJobStartMessage(params: SendJobStartMessageParams): Promise<void> {
+    const message: JobStartMessage = {
+      tenantId: params.tenantId,
+      executionId: params.executionId,
+      jobName: params.jobName,
+    };
+
+    await this.sqsClient.send(
+      new SendMessageCommand({
+        QueueUrl: this.queueUrl,
+        MessageBody: JSON.stringify(message),
+        DelaySeconds: params.delaySeconds ?? 0,
+      }),
+    );
+
+    console.log(
+      `Sent job start message for execution ${params.executionId} (job: ${params.jobName}, tenant: ${params.tenantId}, delay: ${params.delaySeconds ?? 0}s)`,
+    );
+  }
+}

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

@@ -91,7 +91,7 @@ describe('JobUploadService', (): void => {
       await jobUploadService.uploadJobFolder(mockAxiosClient, mockFolderPath, mockBaseTempDir);
 
       expect(mockMkdtemp).toHaveBeenCalledWith('/tmp/job-upload');
-      expect(mockGetAndValidateManifest).toHaveBeenCalledWith(mockAxiosClient, mockFolderPath, expect.any(Object));
+      expect(mockGetAndValidateManifest).toHaveBeenCalledWith(mockAxiosClient, mockFolderPath);
       expect(mockInitializeUpload).toHaveBeenCalledWith(
         mockAxiosClient,
         mockFolderPath,

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

@@ -37,7 +37,7 @@ export class JobUploadService {
     const tmpDir = await fsp.mkdtemp(path.resolve(baseTempDir, 'job-upload'));
 
     try {
-      const manifest = await getAndValidateManifest(apiClient, folderPath, this.logger);
+      const manifest = await getAndValidateManifest(apiClient, folderPath);
 
       const initialUpload = await initializeUpload(apiClient, folderPath, tmpDir, this.logger);
 

package/src/domains/job/services/JobUploadService/utils/manifestValidator.spec.ts

@@ -3,7 +3,6 @@
  * Copyright Squiz Australia Pty Ltd. All Rights Reserved.
  */
 
-import { Logger } from '@squiz/dx-logger-lib';
 import { AxiosInstance } from 'axios';
 import path from 'path';
 import { JobManifestV1, ManifestServiceForDev } from '../../../../manifest';
@@ -24,7 +23,6 @@ jest.mock('path', () => ({
 }));
 
 describe('manifestValidator', () => {
-  let mockLogger: Logger;
   let mockApiClient: AxiosInstance;
   let mockManifestService: jest.Mocked<ManifestServiceForDev>;
   let mockManifest: jest.Mocked<JobManifestV1>;
@@ -34,13 +32,6 @@ describe('manifestValidator', () => {
   beforeEach(() => {
     jest.clearAllMocks();
 
-    mockLogger = {
-      error: jest.fn(),
-      info: jest.fn(),
-      warn: jest.fn(),
-      debug: jest.fn(),
-    } as any;
-
     mockApiClient = {
       get: jest.fn(),
       post: jest.fn(),
@@ -75,9 +66,9 @@ describe('manifestValidator', () => {
     it('should successfully validate manifest when version does not exist', async () => {
       mockCheckIfVersionExists.mockResolvedValue(false);
 
-      const result = await getAndValidateManifest(mockApiClient, testFolderPath, mockLogger);
+      const result = await getAndValidateManifest(mockApiClient, testFolderPath);
 
-      expect(ManifestServiceForDev).toHaveBeenCalledWith(mockLogger);
+      expect(ManifestServiceForDev).toHaveBeenCalledWith();
       expect(mockPathJoin).toHaveBeenCalledWith(testFolderPath, 'manifest.json');
       expect(mockManifestService.readJobManifest).toHaveBeenCalledWith(testManifestPath);
       expect(mockCheckIfVersionExists).toHaveBeenCalledWith(mockApiClient, `/job/${testJobName}/${testJobVersion}`);
@@ -87,7 +78,7 @@ describe('manifestValidator', () => {
     it('should throw error when version already exists', async () => {
       mockCheckIfVersionExists.mockResolvedValue(true);
 
-      await expect(getAndValidateManifest(mockApiClient, testFolderPath, mockLogger)).rejects.toThrow(
+      await expect(getAndValidateManifest(mockApiClient, testFolderPath)).rejects.toThrow(
         `Cannot upload job version, ${testJobName} ${testJobVersion} already exists`,
       );
 
@@ -99,9 +90,7 @@ describe('manifestValidator', () => {
       const manifestError = new Error('Failed to read manifest');
       mockManifestService.readJobManifest.mockRejectedValue(manifestError);
 
-      await expect(getAndValidateManifest(mockApiClient, testFolderPath, mockLogger)).rejects.toThrow(
-        'Failed to read manifest',
-      );
+      await expect(getAndValidateManifest(mockApiClient, testFolderPath)).rejects.toThrow('Failed to read manifest');
 
       expect(mockManifestService.readJobManifest).toHaveBeenCalledWith(testManifestPath);
       expect(mockCheckIfVersionExists).not.toHaveBeenCalled();
@@ -111,9 +100,7 @@ describe('manifestValidator', () => {
       const versionCheckError = new Error('Version check failed');
       mockCheckIfVersionExists.mockRejectedValue(versionCheckError);
 
-      await expect(getAndValidateManifest(mockApiClient, testFolderPath, mockLogger)).rejects.toThrow(
-        'Version check failed',
-      );
+      await expect(getAndValidateManifest(mockApiClient, testFolderPath)).rejects.toThrow('Version check failed');
 
       expect(mockManifestService.readJobManifest).toHaveBeenCalledWith(testManifestPath);
       expect(mockCheckIfVersionExists).toHaveBeenCalledWith(mockApiClient, `/job/${testJobName}/${testJobVersion}`);
@@ -127,7 +114,7 @@ describe('manifestValidator', () => {
       mockManifest.getVersion.mockReturnValue(specialJobVersion);
       mockCheckIfVersionExists.mockResolvedValue(false);
 
-      const result = await getAndValidateManifest(mockApiClient, testFolderPath, mockLogger);
+      const result = await getAndValidateManifest(mockApiClient, testFolderPath);
 
       expect(mockCheckIfVersionExists).toHaveBeenCalledWith(
         mockApiClient,
@@ -141,7 +128,7 @@ describe('manifestValidator', () => {
       mockManifest.getVersion.mockReturnValue(testJobVersion);
       mockCheckIfVersionExists.mockResolvedValue(false);
 
-      const result = await getAndValidateManifest(mockApiClient, testFolderPath, mockLogger);
+      const result = await getAndValidateManifest(mockApiClient, testFolderPath);
 
       expect(mockCheckIfVersionExists).toHaveBeenCalledWith(mockApiClient, `/job//${testJobVersion}`);
       expect(result).toBe(mockManifest);
@@ -152,7 +139,7 @@ describe('manifestValidator', () => {
       mockManifest.getVersion.mockReturnValue('');
       mockCheckIfVersionExists.mockResolvedValue(false);
 
-      const result = await getAndValidateManifest(mockApiClient, testFolderPath, mockLogger);
+      const result = await getAndValidateManifest(mockApiClient, testFolderPath);
 
       expect(mockCheckIfVersionExists).toHaveBeenCalledWith(mockApiClient, `/job/${testJobName}/`);
       expect(result).toBe(mockManifest);
@@ -165,7 +152,7 @@ describe('manifestValidator', () => {
       mockPathJoin.mockReturnValue(expectedManifestPath);
       mockCheckIfVersionExists.mockResolvedValue(false);
 
-      await getAndValidateManifest(mockApiClient, relativePath, mockLogger);
+      await getAndValidateManifest(mockApiClient, relativePath);
 
       expect(mockPathJoin).toHaveBeenCalledWith(relativePath, 'manifest.json');
       expect(mockManifestService.readJobManifest).toHaveBeenCalledWith(expectedManifestPath);
@@ -178,7 +165,7 @@ describe('manifestValidator', () => {
       mockPathJoin.mockReturnValue(expectedManifestPath);
       mockCheckIfVersionExists.mockResolvedValue(false);
 
-      await getAndValidateManifest(mockApiClient, folderPathWithSlash, mockLogger);
+      await getAndValidateManifest(mockApiClient, folderPathWithSlash);
 
       expect(mockPathJoin).toHaveBeenCalledWith(folderPathWithSlash, 'manifest.json');
       expect(mockManifestService.readJobManifest).toHaveBeenCalledWith(expectedManifestPath);
@@ -192,7 +179,7 @@ describe('manifestValidator', () => {
       mockManifest.getVersion.mockReturnValue(complexJobVersion);
       mockCheckIfVersionExists.mockResolvedValue(false);
 
-      await getAndValidateManifest(mockApiClient, testFolderPath, mockLogger);
+      await getAndValidateManifest(mockApiClient, testFolderPath);
 
       expect(mockCheckIfVersionExists).toHaveBeenCalledWith(
         mockApiClient,
@@ -205,7 +192,7 @@ describe('manifestValidator', () => {
       mockManifest.getVersion.mockReturnValue(undefined as any);
       mockCheckIfVersionExists.mockResolvedValue(false);
 
-      await getAndValidateManifest(mockApiClient, testFolderPath, mockLogger);
+      await getAndValidateManifest(mockApiClient, testFolderPath);
 
       expect(mockCheckIfVersionExists).toHaveBeenCalledWith(mockApiClient, `/job/${null}/${undefined}`);
     });

package/src/domains/job/services/JobUploadService/utils/manifestValidator.ts

@@ -3,7 +3,6 @@
  * Copyright Squiz Australia Pty Ltd. All Rights Reserved.
  */
 
-import { Logger } from '@squiz/dx-logger-lib';
 import { AxiosInstance } from 'axios';
 import path from 'path';
 import { JobManifestV1, ManifestServiceForDev } from '../../../../manifest';
@@ -16,12 +15,8 @@ import { checkIfVersionExists } from './versionChecker';
  * @param logger - Logger instance
  * @returns The validated manifest
  */
-export async function getAndValidateManifest(
-  apiClient: AxiosInstance,
-  folderPath: string,
-  logger: Logger,
-): Promise<JobManifestV1> {
-  const manifestService = new ManifestServiceForDev(logger);
+export async function getAndValidateManifest(apiClient: AxiosInstance, folderPath: string): Promise<JobManifestV1> {
+  const manifestService = new ManifestServiceForDev();
   const manifestPath = path.join(folderPath, 'manifest.json');
 
   const manifest = await manifestService.readJobManifest(manifestPath);

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

@@ -1,5 +1,6 @@
 export * from './JobContextService/JobContextService';
 export * from './JobExecutionTaskService/JobExecutionTaskService';
 export * from './JobManifestService/JobManifestService';
-export * from './JobQueueService/JobQueueService';
+export * from './JobStartQueueService/JobStartQueueService';
+export * from './JobStartQueueService/JobStartQueueService.defs';
 export * from './JobUploadService/JobUploadService';

package/src/domains/job/utils/SlackClient/SlackClient.spec.ts

@@ -134,8 +134,6 @@ describe('SlackClient singleton methods', () => {
 
     beforeEach(() => {
       mockMessage = faker.lorem.sentence();
-
-      jest.resetAllMocks();
     });
 
     it('should make a POST request to the Slack webhook URL', async () => {

package/src/domains/manifest/services/ManifestServiceForDev.spec.ts

@@ -3,10 +3,9 @@ import { ManifestServiceForDev } from './ManifestServiceForDev';
 import path from 'path';
 import { ManifestValidationError } from '../errors/ManifestValidationError';
 import { ResourceNotFoundError } from '@squiz/dx-common-lib';
-import { getLogger } from '@squiz/dx-logger-lib';
 
 describe('ManifestServiceForDev', () => {
-  const service = new ManifestServiceForDev(getLogger({ name: 'ManifestServiceForDev' }));
+  const service = new ManifestServiceForDev();
 
   describe('readJobManifest', () => {
     it('should read and validate a job manifest from a file path', async () => {

package/src/domains/manifest/services/ManifestServiceForDev.ts

@@ -4,15 +4,11 @@ import { JobManifestModel } from '../ManifestModel';
 import { getAndAssertJobManifestVersion } from '../utils/getAndAssertJobManifestVersion';
 import { JobManifestV1 } from '../../job/manifest/JobManifestV1';
 import { JsonValidationService } from '@squiz/dx-json-schema-lib';
-
 import fsExtra from 'fs-extra';
-import { Logger } from '@squiz/dx-logger-lib';
 
 export class ManifestServiceForDev {
   protected jobValidationService: JsonValidationService = new JsonValidationService();
 
-  constructor(protected logger: Logger) {}
-
   protected getJobManifest(manifestModel: JobManifestModel, manifestPath: string): JobManifestV1 {
     const schemaVersion = getAndAssertJobManifestVersion(manifestModel, JobManifestV1.getJobSchemaVersionRegex());
     if (schemaVersion === 'JobV1') {

package/src/index.ts

@@ -2,3 +2,4 @@ export * from './domains/manifest/ManifestModel';
 export * from './domains/component';
 export * from './domains/job';
 export * from './domains/manifest';
+export * from './utils';

package/src/jest-global-setup.ts

@@ -2,8 +2,12 @@
  * @license
  * Copyright Squiz Australia Pty Ltd. All Rights Reserved.
  */
-import { getLogger } from '@squiz/dx-logger-lib';
+import { Logger } from '@squiz/optimization-logger';
 
-export const testLogger = getLogger({
-  name: 'component-lib-test',
-});
+export const testLogger: Logger = {
+  audit: jest.fn(),
+  error: jest.fn(),
+  warn: jest.fn(),
+  info: jest.fn(),
+  debug: jest.fn(),
+};