@forge/events 0.0.0-experimental-d18f8dd → 0.0.0-experimental-416047f

package/src/__test__/invocationError.test.ts

@@ -0,0 +1,23 @@
+import { RetryOptions } from '../retryOptions';
+import { InvocationError } from '../invocationError';
+import { InvocationErrorCode } from '../invocationErrorCode';
+
+describe('InvocationError tests', () => {
+  const defaultRetryOption = new RetryOptions();
+  let target = new InvocationError();
+
+  it('Populate invocationError with default retryOptions and expect default retry option', async () => {
+    expect(target.retryOptions.retryAfter).toEqual(defaultRetryOption.retryAfter);
+    expect(target.retryOptions.retryReason).toEqual(InvocationErrorCode.FUNCTION_RETRY_REQUEST);
+    expect((target as any).hasOwnProperty('_retry')).toBe(true);
+  });
+
+  it('Populate InvocationError with custom RetryOptions and expect the custom value to set.', () => {
+    defaultRetryOption.retryAfter = 10;
+    defaultRetryOption.retryReason = InvocationErrorCode.FUNCTION_OUT_OF_MEMORY;
+    target = new InvocationError(defaultRetryOption);
+
+    expect(target.retryOptions).toEqual(defaultRetryOption);
+    expect((target as any).hasOwnProperty('_retry')).toBe(true);
+  });
+});

package/src/__test__/jobProgress.test.ts

@@ -37,7 +37,7 @@ describe('JobProgress methods', () => {
       );
       const jobProgress = getJobProgress(apiClientMock, 'test-queue-name#test-job-id');
       await expect(jobProgress.getStats()).rejects.toThrow(
-        new JobDoesNotExistError(`The job test-job-id doesn't exist for the queue test-queue-name.`)
+        new JobDoesNotExistError(`The job test-job-id was not found for the queue test-queue-name.`)
       );
       verifyApiClientCalledWith(apiClientMock, '/webhook/queue/stats/{cloudId}/{environmentId}/{appId}/{appVersion}', {
         queueName: 'test-queue-name',
@@ -75,6 +75,37 @@ describe('JobProgress methods', () => {
     });
   });
 
+  describe('cancel', () => {
+    it('should call the queue/cancel endpoint', async () => {
+      const apiClientMock = getApiClientMock({}, 204);
+      const jobProgress = getJobProgress(apiClientMock, 'test-queue-name#test-job-id');
+      const response = await jobProgress.cancel();
+      verifyApiClientCalledWith(apiClientMock, '/webhook/queue/cancel/{cloudId}/{environmentId}/{appId}/{appVersion}', {
+        queueName: 'test-queue-name',
+        jobId: 'test-job-id'
+      });
+      expect(response.status).toEqual(204);
+    });
+
+    it('should throw JobDoesNotExistError', async () => {
+      const apiClientMock = getApiClientMock(
+        {
+          message: 'Job Not Found',
+          code: 404
+        },
+        404
+      );
+      const jobProgress = getJobProgress(apiClientMock, 'test-queue-name#test-job-id');
+      await expect(jobProgress.cancel()).rejects.toThrow(
+        new JobDoesNotExistError(`The job test-job-id was not found for the queue test-queue-name.`)
+      );
+      verifyApiClientCalledWith(apiClientMock, '/webhook/queue/cancel/{cloudId}/{environmentId}/{appId}/{appVersion}', {
+        queueName: 'test-queue-name',
+        jobId: 'test-job-id'
+      });
+    });
+  });
+
   it('should throw InternalServerError when WHP returns 422 response', async () => {
     const apiClientMock = getApiClientMock(
       {

package/src/__test__/queue.test.ts

@@ -55,8 +55,8 @@ describe('Queue methods', () => {
     it('should throw TooManyEventsError', async () => {
       const apiClientMock = getApiClientMock();
       const queue = getQueue(apiClientMock, 'name');
-      await expect(queue.push([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])).rejects.toThrow(
-        new TooManyEventsError(`Maximum of 10 events allowed in a single push.`)
+      await expect(queue.push([...Array(51).keys()])).rejects.toThrow(
+        new TooManyEventsError(`This push contains more than the 50 events allowed.`)
       );
       expect(apiClientMock).toHaveBeenCalledTimes(0);
     });
@@ -73,7 +73,7 @@ describe('Queue methods', () => {
     it('should throw RateLimitError', async () => {
       const apiClientMock = getApiClientMock({}, 429);
       const queue = getQueue(apiClientMock, 'name');
-      const payload = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+      const payload = [...Array(10).keys()];
       await expect(queue.push(payload)).rejects.toThrow(new RateLimitError(`Too many requests.`));
       verifyApiClientCalledPushPathWith(apiClientMock, payload, 'name');
     });
@@ -81,8 +81,10 @@ describe('Queue methods', () => {
     it('should throw InvocationLimitReachedError', async () => {
       const apiClientMock = getApiClientMock({}, 405);
       const queue = getQueue(apiClientMock, 'name');
-      const payload = [1, 2, 3, 4, 5];
-      await expect(queue.push(payload)).rejects.toThrow(new InvocationLimitReachedError());
+      const payload = [...Array(5).keys()];
+      await expect(queue.push(payload)).rejects.toThrow(
+        new InvocationLimitReachedError(`The limit on cyclic invocation has been reached.`)
+      );
       verifyApiClientCalledPushPathWith(apiClientMock, payload, 'name');
     });
 
@@ -203,7 +205,7 @@ describe('Queue methods', () => {
         500
       );
       const queue = getQueue(apiClientMock, 'name');
-      const payload = [1, 2, 3, 4, 5, 6, 7, 8, 9];
+      const payload = [...Array(9).keys()];
       await expect(queue.push(payload)).rejects.toThrow(
         new InternalServerError(
           `500 Status Text: AWS SQS timed out`,

package/src/__test__/retryOptions.test.ts

@@ -0,0 +1,14 @@
+import { RetryOptions } from '../retryOptions';
+
+describe('RetryOptions tests', () => {
+  const target = new RetryOptions();
+
+  it.each([
+    [RetryOptions.MIN_RETRY_AFTER, RetryOptions.MIN_RETRY_AFTER],
+    [RetryOptions.MIN_RETRY_AFTER - 1, RetryOptions.MIN_RETRY_AFTER],
+    [RetryOptions.MIN_RETRY_AFTER + 1, RetryOptions.MIN_RETRY_AFTER + 1]
+  ])('try to set retryAfter to %p, expect retryAfter to be %p', (value: number, result: number) => {
+    target.retryAfter = value;
+    expect(target.retryAfter).toEqual(result);
+  });
+});

package/src/errors.ts

@@ -63,7 +63,7 @@ export class JobDoesNotExistError extends Error {
 }
 
 export class InvocationLimitReachedError extends Error {
-  constructor() {
-    super();
+  constructor(message: string) {
+    super(message);
   }
 }

package/src/index.ts

@@ -13,3 +13,6 @@ export {
 } from './errors';
 export { JobProgress } from './jobProgress';
 export { QueueResponse } from './queueResponse';
+export { InvocationError } from './invocationError';
+export { InvocationErrorCode } from './invocationErrorCode';
+export { RetryOptions } from './retryOptions';

package/src/invocationError.ts

@@ -0,0 +1,8 @@
+import { RetryOptions } from './retryOptions';
+import { Response } from './queueResponse';
+
+export class InvocationError extends Response {
+  constructor(public retryOptions: RetryOptions = new RetryOptions()) {
+    super(true);
+  }
+}

package/src/invocationErrorCode.ts

@@ -0,0 +1,8 @@
+export enum InvocationErrorCode {
+  FUNCTION_OUT_OF_MEMORY,
+  FUNCTION_TIME_OUT,
+  FUNCTION_PLATFORM_UNKNOWN_ERROR,
+  FUNCTION_PLATFORM_RATE_LIMITED,
+  FUNCTION_UPSTREAM_RATE_LIMITED,
+  FUNCTION_RETRY_REQUEST
+}

package/src/jobProgress.ts

@@ -1,6 +1,11 @@
-import { GET_STATS_PATH, post } from './queries';
-import { validateGetStatsAPIResponse, validateGetStatsPayload } from './validators';
-import { APIResponse, FetchMethod, GetStatsRequest } from './types';
+import { CANCEL_JOB_PATH, GET_STATS_PATH, post } from './queries';
+import {
+  validateCancelJobAPIResponse,
+  validateCancelJobRequest,
+  validateGetStatsAPIResponse,
+  validateGetStatsPayload
+} from './validators';
+import { APIResponse, CancelJobRequest, FetchMethod, GetStatsRequest } from './types';
 
 export class JobProgress {
   private readonly apiClient: FetchMethod;
@@ -25,4 +30,19 @@ export class JobProgress {
     await validateGetStatsAPIResponse(response, getStatsRequest);
     return response;
   }
+
+  async cancel(): Promise<APIResponse> {
+    const [queueName, jobId] = this.id.split('#');
+    const cancelJobRequest: CancelJobRequest = {
+      queueName: queueName,
+      jobId: jobId,
+      time: new Date().toISOString()
+    };
+
+    validateCancelJobRequest(cancelJobRequest);
+
+    const response = await post(CANCEL_JOB_PATH, cancelJobRequest, this.apiClient);
+    await validateCancelJobAPIResponse(response, cancelJobRequest);
+    return response;
+  }
 }

package/src/queries.ts

@@ -2,6 +2,7 @@ import { APIRequest, APIResponse, FetchMethod } from './types';
 
 export const PUSH_PATH = '/webhook/queue/publish/{cloudId}/{environmentId}/{appId}/{appVersion}';
 export const GET_STATS_PATH = '/webhook/queue/stats/{cloudId}/{environmentId}/{appId}/{appVersion}';
+export const CANCEL_JOB_PATH = '/webhook/queue/cancel/{cloudId}/{environmentId}/{appId}/{appVersion}';
 
 export const post = async (endpoint: string, body: APIRequest, apiClient: FetchMethod): Promise<APIResponse> => {
   const request = {

package/src/queueResponse.ts

@@ -1,5 +1,11 @@
-export class QueueResponse {
-  protected _retry = false;
+export class Response {
+  constructor(protected _retry: boolean) {}
+}
+
+export class QueueResponse extends Response {
+  constructor() {
+    super(false);
+  }
 
   retry(): void {
     this._retry = true;

package/src/retryOptions.ts

@@ -0,0 +1,26 @@
+import { InvocationErrorCode } from './invocationErrorCode';
+
+export class RetryOptions {
+  static readonly MIN_RETRY_AFTER = 1;
+
+  private _retryAfter = RetryOptions.MIN_RETRY_AFTER;
+
+  public retryReason: InvocationErrorCode = InvocationErrorCode.FUNCTION_RETRY_REQUEST;
+
+  /**
+   * Sets the retryAfter option to indicate seconds to wait before attempting a retry.
+   * @param valueInSeconds new value in seconds
+   */
+  set retryAfter(valueInSeconds: number) {
+    if (valueInSeconds >= RetryOptions.MIN_RETRY_AFTER) {
+      this._retryAfter = valueInSeconds;
+    }
+  }
+
+  /**
+   * Returns value of retryAfter to indicate seconds to wait before attempting a retry.
+   */
+  get retryAfter(): number {
+    return this._retryAfter;
+  }
+}

package/src/text.ts

@@ -3,12 +3,13 @@ export const Text = {
     invalidQueueName: `Queue names can only contain alphanumeric characters, dashes and underscores.`,
     invalidDelayInSecondsSetting: `The delayInSeconds setting must be between 0 and 900.`,
     maxEventsAllowed: (maxEventsCount: number): string =>
-      `Maximum of ${maxEventsCount} events allowed in a single push.`,
+      `This push contains more than the ${maxEventsCount} events allowed.`,
     maxPayloadAllowed: (maxPayloadSize: number): string => `The maximum payload size is ${maxPayloadSize}KB.`,
     noEventsPushed: `No events pushed.`,
     rateLimitError: `Too many requests.`,
+    invocationLimitReachedError: `The limit on cyclic invocation has been reached.`,
     jobIdEmpty: `jobId cannot be empty.`,
     jobDoesNotExit: (jobId: string, queueName: string): string =>
-      `The job ${jobId} doesn't exist for the queue ${queueName}.`
+      `The job ${jobId} was not found for the queue ${queueName}.`
   }
 };

package/src/types.ts

@@ -30,3 +30,4 @@ export interface FailedEvent {
 }
 
 export type GetStatsRequest = APIRequest;
+export type CancelJobRequest = APIRequest;

package/src/validators.ts

@@ -11,10 +11,10 @@ import {
   InvocationLimitReachedError
 } from './errors';
 import { Text } from './text';
-import { APIResponse, GetStatsRequest, Payload, PushRequest, PushSettings } from './types';
+import { APIResponse, CancelJobRequest, GetStatsRequest, Payload, PushRequest, PushSettings } from './types';
 
 const VALID_QUEUE_NAME_PATTERN = /^[a-zA-Z0-9-_]+$/;
-const MAXIMUM_EVENTS = 10;
+const MAXIMUM_EVENTS = 50;
 const MAXIMUM_PAYLOAD_SIZE_KB = 200;
 
 export const validateQueueKey = (queueName: string) => {
@@ -51,13 +51,20 @@ export const validateGetStatsPayload = (getStatsRequest: GetStatsRequest) => {
   validateQueueKey(getStatsRequest.queueName);
 };
 
+export const validateCancelJobRequest = (cancelJobRequest: CancelJobRequest) => {
+  if (!cancelJobRequest.jobId) {
+    throw new JobDoesNotExistError(Text.error.jobIdEmpty);
+  }
+  validateQueueKey(cancelJobRequest.queueName);
+};
+
 export const validateAPIResponse = async (response: APIResponse, expectedSuccessStatus: number) => {
   if (response.status === 429) {
     throw new RateLimitError(Text.error.rateLimitError);
   }
 
   if (response.status === 405) {
-    throw new InvocationLimitReachedError();
+    throw new InvocationLimitReachedError(Text.error.invocationLimitReachedError);
   }
 
   if (response.status != expectedSuccessStatus && response.status) {
@@ -125,3 +132,11 @@ export const validateGetStatsAPIResponse = async (response: APIResponse, getStat
 
   await validateAPIResponse(response, 200);
 };
+
+export const validateCancelJobAPIResponse = async (response: APIResponse, cancelJobRequest: GetStatsRequest) => {
+  if (response.status === 404) {
+    throw new JobDoesNotExistError(Text.error.jobDoesNotExit(cancelJobRequest.jobId, cancelJobRequest.queueName));
+  }
+
+  await validateAPIResponse(response, 204);
+};