@factorearth/recordmiddleware-errorhandler 0.0.1-y.24 → 0.0.1-y.25

package/dist/aws-services/dynamodb/determineRetryableDynamo.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Given the error from the dynamodb operation, dertermines if we can retry it, based on the information from the dynamodb sdk docs
+ * {@link https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Programming.Errors.html}
+ * @author Eric Webb <ewebb@factorearth.com>
+ * @param err The error thrown by the dynamodb operation
+ * @returns Whether or not we can retry the operation
+ */
+export declare function determineRetryableDynamo(err: any): boolean;

package/dist/aws-services/dynamodb/determineRetryableDynamo.js

@@ -0,0 +1,14 @@
+/**
+ * Given the error from the dynamodb operation, dertermines if we can retry it, based on the information from the dynamodb sdk docs
+ * {@link https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Programming.Errors.html}
+ * @author Eric Webb <ewebb@factorearth.com>
+ * @param err The error thrown by the dynamodb operation
+ * @returns Whether or not we can retry the operation
+ */
+export function determineRetryableDynamo(err) {
+    if (!err?.name)
+        return false;
+    // The errors from the link I provided that are marked as retryable
+    const retryableErrors = new Set(["ItemCollectionSizeLimitExceededException", "LimitExceededException", "ProvisionedThroughputExceededException", "RequestLimitExceeded", "ThrottlingException"]);
+    return retryableErrors.has(err.name) || (err.$metadata && err.$metadata.httpStatusCode && err.$metadata.httpStatusCode >= 500);
+}

package/dist/backOff.d.ts

@@ -0,0 +1,28 @@
+interface BackoffOptions {
+    /**
+     * The initial delay you want to apply. Default to 100ms
+     */
+    delay?: number;
+    /**
+     * The number of times you want to attempt the function. Default 10
+     */
+    numberOfAttempts?: number;
+    /**
+     * An optional max delay
+     */
+    maxDelay?: number;
+    /**
+     * An initial multiplier to be taken to the power of the attempt number when deciding how long to wait. Default value of 2
+     */
+    timeMultiple?: number;
+}
+/**
+ * Given a task, attempts to execute it a designated number of times, returning the eventual response
+ * @author Eric Webb <ewebb@factorearth.com>
+ * @param task The task we want to retry potentially
+ * @param evaluator A function to evaluate if the task executed successfully, or if it needs to be retried. Needs to return boolean
+ * @param options The configurable options for the module
+ * @returns The result of the function
+ */
+export declare function backoff<TaskResult, TaskArguments extends any[]>(task: (...args: TaskArguments) => Promise<TaskResult>, evaluator: (taskResult: TaskResult) => boolean, options?: BackoffOptions, ...taskArguments: TaskArguments): Promise<TaskResult | void>;
+export {};

package/dist/backOff.js

@@ -0,0 +1,36 @@
+import { delay } from "./delay";
+// Default values
+const DELAY = 100;
+const NUMBER_OF_ATTEMPTS = 10;
+const MAX_DELAY = Infinity;
+const TIME_MULTIPLE = 2;
+/**
+ * Given a task, attempts to execute it a designated number of times, returning the eventual response
+ * @author Eric Webb <ewebb@factorearth.com>
+ * @param task The task we want to retry potentially
+ * @param evaluator A function to evaluate if the task executed successfully, or if it needs to be retried. Needs to return boolean
+ * @param options The configurable options for the module
+ * @returns The result of the function
+ */
+export async function backoff(task, evaluator, options, ...taskArguments) {
+    let attemptNumber = 0;
+    const maxAttempts = options?.numberOfAttempts || NUMBER_OF_ATTEMPTS;
+    const initialDelay = options?.delay || DELAY;
+    const maxDelay = options?.maxDelay || MAX_DELAY;
+    const timeMultiple = options?.timeMultiple || TIME_MULTIPLE;
+    while (attemptNumber < maxAttempts) {
+        const calculatedDelay = initialDelay * Math.pow(timeMultiple, attemptNumber);
+        const delayTime = Math.min(calculatedDelay, maxDelay);
+        await delay(delayTime);
+        try {
+            const taskResult = await task(...taskArguments);
+            const evaluatorResult = evaluator(taskResult);
+            if (evaluatorResult || !(attemptNumber + 1 < maxAttempts))
+                return taskResult;
+        }
+        catch (err) {
+            // recordSentry({ error: err, msg: "Error executing backoff task" });
+        }
+        attemptNumber++;
+    }
+}

package/dist/delay.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Creates a promise that resolvers after a provided number of ms
+ * @author Eric Webb <ewebb@factorearth.com>
+ * @param millis The number of ms you want to sleep
+ * @returns A void promise
+ */
+export declare function delay(millis: number): Promise<any>;

package/dist/delay.js

@@ -0,0 +1,9 @@
+/**
+ * Creates a promise that resolvers after a provided number of ms
+ * @author Eric Webb <ewebb@factorearth.com>
+ * @param millis The number of ms you want to sleep
+ * @returns A void promise
+ */
+export function delay(millis) {
+    return new Promise((resolve, _reject) => setTimeout(resolve, millis));
+}

package/dist/handler.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Takes a given error, determines if we can bother retrying the operation, and re-attempts the operation
+ * @author Eric Webb <ewebb@factorearth.com>
+ * @param err The error thrown by the dynamodb sdk
+ * @param task The task that we need to try and perform, if it can be retried
+ * @param evaluator The function that evaluates the success of the task
+ * @param taskArguments The arguments we need to pass into the task
+ * @returns The result of the task, or the error that prevented it from executing
+ */
+export declare function handler<TaskResult, TaskArguments extends any[]>(err: unknown, task: (...args: TaskArguments[]) => Promise<TaskResult>, evaluator: (result: TaskResult) => boolean, ...taskArguments: TaskArguments): Promise<unknown>;

package/dist/handler.js

@@ -0,0 +1,19 @@
+import { determineRetryableDynamo } from "./aws-services/dynamodb/determineRetryableDynamo";
+import { backoff } from "./backOff";
+/**
+ * Takes a given error, determines if we can bother retrying the operation, and re-attempts the operation
+ * @author Eric Webb <ewebb@factorearth.com>
+ * @param err The error thrown by the dynamodb sdk
+ * @param task The task that we need to try and perform, if it can be retried
+ * @param evaluator The function that evaluates the success of the task
+ * @param taskArguments The arguments we need to pass into the task
+ * @returns The result of the task, or the error that prevented it from executing
+ */
+export async function handler(err, task, evaluator, ...taskArguments) {
+    const canBeRetried = determineRetryableDynamo(err);
+    if (canBeRetried) {
+        const result = await backoff(task, evaluator, undefined, ...taskArguments);
+        return result;
+    }
+    return err;
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./aws-services/dynamodb/determineRetryableDynamo";
+export * from "./backOff";
+export * from "./handler";

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from "./aws-services/dynamodb/determineRetryableDynamo";
+export * from "./backOff";
+export * from "./handler";

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@factorearth/recordmiddleware-errorhandler",
-	"version": "0.0.1-y.24",
+	"version": "0.0.1-y.25",
 	"description": "A module for handling CRUD errors in lambda",
 	"author": "madtrx <marlin.makori@gmail.com>",
 	"homepage": "https://github.com/FactorEarth/RecordMiddleware#readme",
@@ -24,5 +24,5 @@
 		"access": "public",
 		"registry": "https://registry.npmjs.org/"
 	},
-	"gitHead": "49e25c03c2ba02f2613958c90e18e82173d5865a"
+	"gitHead": "45082bcb7811baf349b0febc1bf1a568b3d3e418"
 }