@forge/events 0.0.0-experimental-d3a39c9 → 0.0.0-experimental-490cfcf

package/src/validators.ts

@@ -1,44 +1,95 @@
 import {
   InternalServerError,
   InvalidQueueNameError,
+  JobDoesNotExistError,
   NoEventsToPushError,
   PartialSuccessError,
   PayloadTooBigError,
   RateLimitError,
-  TooManyEventsError
+  TooManyEventsError,
+  InvalidPushSettingsError,
+  InvocationLimitReachedError
 } from './errors';
-import { APIResponse, Payload, APIRequest } from './types';
+import { Text } from './text';
+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 validateQueueName = (queueName: string) => {
+export const validateQueueKey = (queueName: string) => {
   if (!queueName || !VALID_QUEUE_NAME_PATTERN.test(queueName)) {
-    throw new InvalidQueueNameError('Queue name can only contain alphanumeric, dash and underscore characters');
+    throw new InvalidQueueNameError(Text.error.invalidQueueName);
   }
 };
 
-export const validatePayloads = (payloads: Payload | Payload[]) => {
+export const validatePushSettings = (settings: PushSettings) => {
+  if ((settings.delayInSeconds && settings.delayInSeconds > 900) || settings.delayInSeconds < 0) {
+    throw new InvalidPushSettingsError(Text.error.invalidDelayInSecondsSetting);
+  }
+};
+
+export const validatePushPayloads = (payloads: Payload | Payload[]) => {
   if (!payloads || (Array.isArray(payloads) && payloads.length === 0)) {
-    throw new NoEventsToPushError(`No events pushed`);
+    throw new NoEventsToPushError(Text.error.noEventsPushed);
   }
 
   if (Array.isArray(payloads) && payloads.length > MAXIMUM_EVENTS) {
-    throw new TooManyEventsError(`Maximum of ${MAXIMUM_EVENTS} events allowed in a single push`);
+    throw new TooManyEventsError(Text.error.maxEventsAllowed(MAXIMUM_EVENTS));
   }
 
   const payloadSizeKB = Buffer.byteLength(JSON.stringify(payloads)) / 1024;
   if (payloadSizeKB > MAXIMUM_PAYLOAD_SIZE_KB) {
-    throw new PayloadTooBigError(`The maximum payload size allowed is ${MAXIMUM_PAYLOAD_SIZE_KB}KB`);
+    throw new PayloadTooBigError(Text.error.maxPayloadAllowed(MAXIMUM_PAYLOAD_SIZE_KB));
+  }
+};
+
+export const validateGetStatsPayload = (getStatsRequest: GetStatsRequest) => {
+  if (!getStatsRequest.jobId) {
+    throw new JobDoesNotExistError(Text.error.jobIdEmpty);
+  }
+  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, requestBody: APIRequest) => {
+export const validateAPIResponse = async (response: APIResponse, expectedSuccessStatus: number) => {
   if (response.status === 429) {
-    throw new RateLimitError(`Too many requests`);
+    throw new RateLimitError(Text.error.rateLimitError);
   }
 
+  if (response.status === 405) {
+    throw new InvocationLimitReachedError(Text.error.invocationLimitReachedError);
+  }
+
+  if (response.status != expectedSuccessStatus && response.status) {
+    //Catch all errors from server that we have not handled
+    let internalServerError;
+
+    try {
+      const responseBody = await response.json();
+      const errorMessage = responseBody.message ? `: ${responseBody.message}` : '';
+      const errors = responseBody.errors ? `: ${responseBody.errors.join(', ')}` : ''; //Dropwizard returns an array of errors when request body validation failed
+      internalServerError = new InternalServerError(
+        `${response.status} ${response.statusText}${errorMessage}${errors}`,
+        responseBody.code,
+        responseBody.details
+      );
+    } catch (ignore) {
+      //response body is not a json
+      internalServerError = new InternalServerError(`${response.status} ${response.statusText}`, response.status);
+    }
+
+    throw internalServerError;
+  }
+};
+
+export const validatePushAPIResponse = async (response: APIResponse, requestBody: PushRequest) => {
   if (response.status === 413) {
     //Server can return this error response if it has a different max payload size and max number of events limits
     const responseBody = await response.json();
@@ -47,29 +98,45 @@ export const validateAPIResponse = async (response: APIResponse, requestBody: AP
 
   if (response.status === 202) {
     const responseBody = await response.json();
+    const defaultErrorMessage = 'Failed to process some events.';
+    const partialSuccessError = new PartialSuccessError(defaultErrorMessage, []);
+
     if (responseBody.failedEvents && responseBody.failedEvents.length > 0) {
-      throw new PartialSuccessError(
-        `Failed to process ${responseBody.failedEvents.length} events`,
-        responseBody.failedEvents.map((failedEvent: any) => {
-          return {
-            errorMessage: failedEvent.errorMessage,
-            payload: requestBody.payload[+failedEvent.index]
-          };
-        })
-      );
-    } else {
-      throw new PartialSuccessError(`Failed to process events`, []);
+      partialSuccessError.message = `Failed to process ${responseBody.failedEvents.length} event(s).`;
+      partialSuccessError.failedEvents = responseBody.failedEvents.map((failedEvent: any) => {
+        return {
+          errorMessage: failedEvent.errorMessage,
+          payload: requestBody.payload[+failedEvent.index]
+        };
+      });
     }
+
+    if (responseBody.errorMessage) {
+      //Append any extra error message from backend
+      partialSuccessError.message =
+        partialSuccessError.message !== defaultErrorMessage
+          ? `${partialSuccessError.message} ${responseBody.errorMessage}`
+          : responseBody.errorMessage;
+    }
+
+    throw partialSuccessError;
   }
 
-  if (response.status != 201 && response.status) {
-    //Catch all errors from server that we have not handled
-    const responseBody = await response.json();
-    const errorMessage = responseBody.message ? `: ${responseBody.message}` : '';
-    throw new InternalServerError(
-      `${response.status} ${response.statusText}${errorMessage}`,
-      responseBody.code,
-      responseBody.details
-    );
+  await validateAPIResponse(response, 201);
+};
+
+export const validateGetStatsAPIResponse = async (response: APIResponse, getStatsRequest: GetStatsRequest) => {
+  if (response.status === 404) {
+    throw new JobDoesNotExistError(Text.error.jobDoesNotExit(getStatsRequest.jobId, getStatsRequest.queueName));
+  }
+
+  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);
 };

package/tsconfig.json

@@ -1,10 +1,13 @@
 {
-    "extends": "../../tsconfig-base.json",
-    "compilerOptions": {
-      "outDir": "./out",
-      "rootDir": "src",
-      "composite": true
-    },
-    "references": []
-  }
-  
+  "extends": "../../tsconfig-base.json",
+  "compilerOptions": {
+    "outDir": "./out",
+    "rootDir": "src",
+    "composite": true
+  },
+  "references": [
+    {
+      "path": "../forge-api"
+    }
+  ]
+}