@squiz/job-runner-lib 1.66.2 → 2.2.0

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

@@ -0,0 +1,36 @@
+/*!
+ * @license
+ * Copyright Squiz Australia Pty Ltd. All Rights Reserved.
+ */
+
+import { zipDirectory } from '@squiz/dx-common-lib';
+import { Logger } from '@squiz/dx-logger-lib';
+import { AxiosInstance } from 'axios';
+import { handleResponse } from './responseHandler';
+
+export interface InitialUpload {
+  zip: string;
+  upload: any; // Keep as any to match the original API response
+}
+
+/**
+ * Initialize upload by zipping folder and creating upload request
+ * @param apiClient - Axios client for API calls
+ * @param folderPath - Path to the job folder
+ * @param tmpDir - Temporary directory for zip file
+ * @param logger - Logger instance
+ * @returns Upload information
+ */
+export async function initializeUpload(
+  apiClient: AxiosInstance,
+  folderPath: string,
+  tmpDir: string,
+  logger: Logger,
+): Promise<InitialUpload> {
+  logger.info('Initial scanning');
+  const zip = await zipDirectory(folderPath, tmpDir);
+  const upload = await handleResponse<any>(apiClient.post('/upload-job', {}));
+  logger.info(`deployment id: ${upload.id} status: transferring`);
+
+  return { zip, upload };
+}

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

@@ -0,0 +1,70 @@
+/*!
+ * @license
+ * Copyright Squiz Australia Pty Ltd. All Rights Reserved.
+ */
+
+import { AxiosError, AxiosInstance, AxiosResponse } from 'axios';
+import { checkIfVersionExists } from './versionChecker';
+
+describe('versionChecker', () => {
+  let mockAxiosClient: AxiosInstance;
+
+  beforeEach(() => {
+    mockAxiosClient = {
+      get: jest.fn(),
+    } as any;
+  });
+
+  describe('checkIfVersionExists', () => {
+    it('should return true when version exists (200 response)', async () => {
+      (mockAxiosClient.get as jest.Mock).mockResolvedValue({ status: 200 } as AxiosResponse);
+
+      const result = await checkIfVersionExists(mockAxiosClient, '/job/test/1.0.0');
+
+      expect(result).toBe(true);
+      expect(mockAxiosClient.get).toHaveBeenCalledWith('/job/test/1.0.0', { validateStatus: null });
+    });
+
+    it('should return false when version does not exist (404 response)', async () => {
+      (mockAxiosClient.get as jest.Mock).mockResolvedValue({ status: 404 } as AxiosResponse);
+
+      const result = await checkIfVersionExists(mockAxiosClient, '/job/test/1.0.0');
+
+      expect(result).toBe(false);
+    });
+
+    it('should throw error for unexpected response status', async () => {
+      (mockAxiosClient.get as jest.Mock).mockResolvedValue({
+        status: 500,
+        statusText: 'Internal Server Error',
+        data: { message: 'Server error' },
+      } as AxiosResponse);
+
+      await expect(checkIfVersionExists(mockAxiosClient, '/job/test/1.0.0')).rejects.toThrow(
+        'Unexpected response code 500. Server error',
+      );
+    });
+
+    it('should handle axios errors', async () => {
+      const axiosError = new AxiosError('Network error');
+      Object.defineProperty(axiosError, 'isAxiosError', { value: true });
+      (mockAxiosClient.get as jest.Mock).mockRejectedValue(axiosError);
+
+      await expect(checkIfVersionExists(mockAxiosClient, '/job/test/1.0.0')).rejects.toThrow(
+        'Network error (code: unknown)',
+      );
+    });
+
+    it('should handle response without error message', async () => {
+      (mockAxiosClient.get as jest.Mock).mockResolvedValue({
+        status: 503,
+        statusText: 'Service Unavailable',
+        data: {},
+      } as AxiosResponse);
+
+      await expect(checkIfVersionExists(mockAxiosClient, '/job/test/1.0.0')).rejects.toThrow(
+        'Service Unavailable (code: 503)',
+      );
+    });
+  });
+});

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

@@ -0,0 +1,39 @@
+/*!
+ * @license
+ * Copyright Squiz Australia Pty Ltd. All Rights Reserved.
+ */
+
+import { AxiosError, AxiosInstance } from 'axios';
+import { handleError } from './errorUtils';
+
+/**
+ * Check if a job version already exists
+ * @param apiClient - Axios client for API calls
+ * @param endpoint - API endpoint to check
+ * @returns True if version exists, false otherwise
+ */
+export async function checkIfVersionExists(apiClient: AxiosInstance, endpoint: string): Promise<boolean> {
+  try {
+    const response = await apiClient.get(endpoint, {
+      validateStatus: null,
+    });
+
+    if (response.status === 200) {
+      return true;
+    } else if (response.status === 404) {
+      return false;
+    }
+
+    const error = new AxiosError(
+      response?.data?.message || response.statusText,
+      response.status.toString(),
+      undefined,
+      undefined,
+      response,
+    );
+
+    throw handleError(error);
+  } catch (error) {
+    throw handleError(error);
+  }
+}

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

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

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

@@ -0,0 +1,45 @@
+import { GetAwsTagsProps } from './GetAwsTags.types';
+import { getAwsTags } from './GetAwsTags';
+
+describe('getAwsTags', () => {
+  it.each([
+    [
+      'Only required props provided',
+      {
+        environment: 'dev',
+        region: 'ap-southest-2',
+      },
+      {
+        Department: 'platform services team',
+        Environment: 'dev',
+        Product: 'job-runner',
+        Purpose: 'job runner service',
+        Region: 'ap-southest-2',
+        'map-migrated': 'migUJ1IX3DUXG',
+      },
+    ],
+    [
+      'All props provided',
+      {
+        environment: 'prod',
+        region: 'us-east-1',
+        tenant: 'unit-test-tenant-0001',
+        product: 'job-runtime',
+      },
+      {
+        Department: 'platform services team',
+        Environment: 'prod',
+        Product: 'job-runtime',
+        Purpose: 'job runner service',
+        Region: 'us-east-1',
+        'map-migrated': 'migUJ1IX3DUXG',
+        'cmp:tenant': 'unit-test-tenant-0001',
+      },
+    ],
+  ])(
+    'Returns the expected tags',
+    (description: string, props: GetAwsTagsProps, expectedTags: Record<string, string>) => {
+      expect(getAwsTags(props)).toStrictEqual(expectedTags);
+    },
+  );
+});

package/src/domains/job/utils/GetAwsTags/GetAwsTags.ts

@@ -0,0 +1,18 @@
+import { GetAwsTagsProps } from './GetAwsTags.types';
+
+export const getAwsTags = (props: GetAwsTagsProps): Record<string, string> => {
+  const tags: Record<string, string> = {
+    Environment: props.environment,
+    Region: props.region,
+    Product: props.product || 'job-runner',
+    Department: 'platform services team',
+    Purpose: 'job runner service',
+    'map-migrated': 'migUJ1IX3DUXG',
+  };
+
+  if (props.tenant) {
+    tags['cmp:tenant'] = props.tenant;
+  }
+
+  return tags;
+};

package/src/domains/job/utils/GetAwsTags/GetAwsTags.types.ts

@@ -0,0 +1,18 @@
+export type GetAwsTagsProps = {
+  /**
+   * The short environment name, eg: dev/stg/prod.
+   */
+  environment: string;
+  /**
+   * The AWS region name, eg: ap-southeast-2, us-east-1.
+   */
+  region: string;
+  /**
+   * The tenant to tag the resource with (undefined for shared resources).
+   */
+  tenant?: string;
+  /**
+   * The product the resource relates to (defaults to "job-runner").s
+   */
+  product?: string;
+};

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

@@ -1,3 +1,5 @@
+export * from './GetAwsTags/GetAwsTags';
+export * from './GetAwsTags/GetAwsTags.types';
 export * from './SlackClient/SlackClient';
 export * from './SlackClient/types/SlackClient.types';
 export * from './SortByTimeQueued/SortByTimeQueued';

package/src/domains/manifest/ManifestModel.ts

@@ -1,9 +1,6 @@
 import { MANIFEST_MODELS } from '@squiz/dx-json-schema-lib';
-import { ManifestV1 } from './ManifestV1';
-
-export type ManifestV1Model = MANIFEST_MODELS.v1.ComponentManifest;
-export type ManifestModel = ManifestV1Model;
-export type Manifest = ManifestV1;
 
 export type JobManifestV1Model = MANIFEST_MODELS.JobV1.JobManifest;
 export type JobManifestModel = JobManifestV1Model;
+export type SchemaVersions = keyof typeof MANIFEST_MODELS;
+export const JOB_SCHEMA_VERSIONS = Object.keys(MANIFEST_MODELS).filter((model) => model.includes('JobV'));

package/src/domains/manifest/index.ts

@@ -1,18 +1,9 @@
-export * from './services/AbstractManifestService';
 export * from './services/ManifestServiceForDev';
-export * from './services/ManifestServiceForProduction';
-export * from './services/ComponentFunctionService';
 export * from './services/JobFunctionService';
 
-export * from './utils/assertFuncEntryFilesAreValid';
-export * from './utils/assertStaticFilesAreValid';
-export * from './utils/getAndAssertManifestVersion';
 export * from './utils/getAndAssertJobManifestVersion';
 export * from './utils/isValidManifestVersion';
 
-export * from './AbstractManifest';
 export * from './ManifestModel';
-export * from './ManifestV1';
 export * from '../job/manifest/JobManifestV1';
-export * from './errors/ManifestLocationError';
 export * from './errors/ManifestValidationError';

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

@@ -1,22 +1,10 @@
-import {
-  JSONSchemaService,
-  SquizImageType,
-  SquizLinkType,
-  TypeResolver,
-  ManifestV1MetaSchema,
-  BaseFormattedTextType,
-} from '@squiz/dx-json-schema-lib';
+import { JSONSchemaService, TypeResolver, ManifestV1MetaSchema } from '@squiz/dx-json-schema-lib';
+import { AnyPrimitiveType } from '@squiz/dx-json-schema-lib/src/jsonTypeResolution/TypeResolver';
 
-export type ComponentSchemaValidationService = JSONSchemaService<
-  SquizImageType | SquizLinkType | BaseFormattedTextType,
-  never
->;
+export type JobSchemaValidationService = JSONSchemaService<AnyPrimitiveType, never>;
 
-export class ComponentSchemaValidationServiceFactory {
-  public static create(): ComponentSchemaValidationService {
-    return new JSONSchemaService(
-      new TypeResolver([SquizImageType, BaseFormattedTextType, SquizLinkType]),
-      ManifestV1MetaSchema,
-    );
+export class JobSchemaValidationServiceFactory {
+  public static create(): JobSchemaValidationService {
+    return new JSONSchemaService(new TypeResolver([]), ManifestV1MetaSchema);
   }
 }

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

@@ -1,23 +1,20 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
-import { ManifestModel } from '../ManifestModel';
+import { JobManifestModel } from '../ManifestModel';
 import { JobFunctionService } from './JobFunctionService';
-import { ManifestV1 } from '../ManifestV1';
-import { MANIFEST_MODELS } from '@squiz/dx-json-schema-lib';
-
-type ComponentFunction = MANIFEST_MODELS.v1.ComponentFunction;
 
 describe('JobFunctionService', () => {
   const service = new JobFunctionService();
-  const manifestPath = '';
-  const manifestModel: ManifestModel = {
+  const manifestModel: JobManifestModel = {
     $schema: './manifest-schemas/v1.json',
 
     name: 'hello',
     version: '1.0.1',
-    namespace: 'foo',
     displayName: 'some display name',
     description: 'some description',
 
+    timeout: 600,
+    concurrency: 10,
+
     mainFunction: 'hello',
 
     functions: [
@@ -33,16 +30,6 @@ describe('JobFunctionService', () => {
 
           required: ['hello'],
         },
-
-        output: {
-          responseType: 'html',
-        },
-
-        queryParameters: {
-          foo: {
-            required: false,
-          },
-        },
       },
 
       {
@@ -57,53 +44,6 @@ describe('JobFunctionService', () => {
 
           required: ['hello'],
         },
-
-        output: {
-          responseType: 'html',
-
-          staticFiles: [
-            {
-              file: {
-                filepath: './something.png',
-              },
-              location: 'header',
-            },
-
-            {
-              file: {
-                filepath: './sub/sub-dir.png',
-              },
-              location: 'header',
-            },
-
-            {
-              file: {
-                filepath: './sub/../sub-dir-transverse-up.png',
-              },
-              location: 'header',
-            },
-
-            {
-              file: {
-                filepath: '../sub-dir-transverse-up-past-root.png',
-              },
-              location: 'header',
-            },
-
-            {
-              file: {
-                filepath: '/absolute/path.png',
-              },
-              location: 'header',
-            },
-            {
-              file: {
-                filepath: 'no-prefix.png',
-              },
-              location: 'header',
-            },
-          ],
-        },
       },
 
       {
@@ -118,26 +58,12 @@ describe('JobFunctionService', () => {
 
           required: ['hello'],
         },
-
-        output: {
-          responseType: 'json',
-          definition: {
-            type: 'object',
-            properties: {
-              prop: { type: 'string' },
-              obj: { type: 'object', properties: { 'sub-prop': { type: 'number' } }, required: ['sub-prop'] },
-            },
-            additionalProperties: false,
-            required: ['prop', 'obj'],
-          },
-        },
       },
     ],
   };
 
   describe('assertInputValidForJobFunction', () => {
-    const manifest = new ManifestV1(JSON.parse(JSON.stringify(manifestModel)), manifestPath);
-    const jobFunc = manifest.getModel().functions.find((f) => f.name === 'hello') as ComponentFunction;
+    const jobFunc = manifestModel.functions.find((f) => f.name === 'hello');
 
     it('should validate the input for the job function', (): void => {
       const input = {
@@ -145,19 +71,19 @@ describe('JobFunctionService', () => {
         hello: 'world',
       };
 
-      expect(() => service.assertInputValidForJobFunction(input, jobFunc)).not.toThrow();
+      expect(() => service.assertInputValidForJobFunction(input, jobFunc!)).not.toThrow();
     });
 
     it("should throw an error if the input to a component function doesn't meet the schema", () => {
       const input = {};
 
-      expect(() => service.assertInputValidForJobFunction(input, jobFunc)).toThrowErrorMatchingInlineSnapshot(
+      expect(() => service.assertInputValidForJobFunction(input, jobFunc!)).toThrowErrorMatchingInlineSnapshot(
         `"failed validation: The required property \`hello\` is missing at \`#\`"`,
       );
     });
 
     it('should throw an error if input is undefined', () => {
-      expect(() => service.assertInputValidForJobFunction(undefined, jobFunc)).toThrowErrorMatchingInlineSnapshot(
+      expect(() => service.assertInputValidForJobFunction(undefined, jobFunc!)).toThrowErrorMatchingInlineSnapshot(
         `"input value for hello cannot be undefined"`,
       );
     });

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

@@ -1,14 +1,11 @@
 import { BadRequestError } from '@squiz/dx-common-lib';
 import { MANIFEST_MODELS } from '@squiz/dx-json-schema-lib';
-import {
-  ComponentSchemaValidationService,
-  ComponentSchemaValidationServiceFactory,
-} from './ComponentSchemaValidationService';
+import { JobSchemaValidationServiceFactory } from './ComponentSchemaValidationService';
 
 type JobFunction = MANIFEST_MODELS.JobV1.JobFunction;
 
 export class JobFunctionService {
-  private schemaValidationService: ComponentSchemaValidationService = ComponentSchemaValidationServiceFactory.create();
+  private schemaValidationService = JobSchemaValidationServiceFactory.create();
 
   /**
    * Asserts the provided input matches the input schema of the job function