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

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.determineRetryableDynamo = void 0;
+/**
+ * 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
+ */
+function determineRetryableDynamo(err) {
+    if (!(err === null || err === void 0 ? void 0 : err.name))
+        return false;
+    // The errors from the link I provided that are marked as retryable
+    var retryableErrors = new Set(["ItemCollectionSizeLimitExceededException", "LimitExceededException", "ProvisionedThroughputExceededException", "RequestLimitExceeded", "ThrottlingException"]);
+    return retryableErrors.has(err.name) || (err.$metadata && err.$metadata.httpStatusCode && err.$metadata.httpStatusCode >= 500);
+}
+exports.determineRetryableDynamo = determineRetryableDynamo;
+//# sourceMappingURL=determineRetryableDynamo.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"determineRetryableDynamo.js","sourceRoot":"","sources":["../../../lib/aws-services/dynamodb/determineRetryableDynamo.ts"],"names":[],"mappings":";;;AAAA;;;;;;GAMG;AACH,SAAgB,wBAAwB,CAAC,GAAQ;IAChD,IAAI,CAAC,CAAA,GAAG,aAAH,GAAG,uBAAH,GAAG,CAAE,IAAI,CAAA;QAAE,OAAO,KAAK,CAAC;IAC7B,mEAAmE;IACnE,IAAM,eAAe,GAAgB,IAAI,GAAG,CAAC,CAAC,0CAA0C,EAAE,wBAAwB,EAAE,wCAAwC,EAAE,sBAAsB,EAAE,qBAAqB,CAAC,CAAC,CAAC;IAC9M,OAAO,eAAe,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,SAAS,IAAI,GAAG,CAAC,SAAS,CAAC,cAAc,IAAI,GAAG,CAAC,SAAS,CAAC,cAAc,IAAI,GAAG,CAAC,CAAC;AAChI,CAAC;AALD,4DAKC"}

package/dist/backOff.js

@@ -0,0 +1,99 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.backoff = void 0;
+var delay_1 = require("./delay");
+// Default values
+var DELAY = 100;
+var NUMBER_OF_ATTEMPTS = 10;
+var MAX_DELAY = Infinity;
+var 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
+ */
+function backoff(task, evaluator, options) {
+    var taskArguments = [];
+    for (var _i = 3; _i < arguments.length; _i++) {
+        taskArguments[_i - 3] = arguments[_i];
+    }
+    return __awaiter(this, void 0, void 0, function () {
+        var attemptNumber, maxAttempts, initialDelay, maxDelay, timeMultiple, calculatedDelay, delayTime, taskResult, evaluatorResult, err_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    attemptNumber = 0;
+                    maxAttempts = (options === null || options === void 0 ? void 0 : options.numberOfAttempts) || NUMBER_OF_ATTEMPTS;
+                    initialDelay = (options === null || options === void 0 ? void 0 : options.delay) || DELAY;
+                    maxDelay = (options === null || options === void 0 ? void 0 : options.maxDelay) || MAX_DELAY;
+                    timeMultiple = (options === null || options === void 0 ? void 0 : options.timeMultiple) || TIME_MULTIPLE;
+                    _a.label = 1;
+                case 1:
+                    if (!(attemptNumber < maxAttempts)) return [3 /*break*/, 7];
+                    calculatedDelay = initialDelay * Math.pow(timeMultiple, attemptNumber);
+                    delayTime = Math.min(calculatedDelay, maxDelay);
+                    return [4 /*yield*/, (0, delay_1.delay)(delayTime)];
+                case 2:
+                    _a.sent();
+                    _a.label = 3;
+                case 3:
+                    _a.trys.push([3, 5, , 6]);
+                    return [4 /*yield*/, task.apply(void 0, taskArguments)];
+                case 4:
+                    taskResult = _a.sent();
+                    evaluatorResult = evaluator(taskResult);
+                    if (evaluatorResult || !(attemptNumber + 1 < maxAttempts))
+                        return [2 /*return*/, taskResult];
+                    return [3 /*break*/, 6];
+                case 5:
+                    err_1 = _a.sent();
+                    return [3 /*break*/, 6];
+                case 6:
+                    attemptNumber++;
+                    return [3 /*break*/, 1];
+                case 7: return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.backoff = backoff;
+//# sourceMappingURL=backOff.js.map

package/dist/backOff.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"backOff.js","sourceRoot":"","sources":["../lib/backOff.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,iCAAgC;AAqBhC,iBAAiB;AACjB,IAAM,KAAK,GAAG,GAAG,CAAC;AAClB,IAAM,kBAAkB,GAAG,EAAE,CAAC;AAC9B,IAAM,SAAS,GAAG,QAAQ,CAAC;AAC3B,IAAM,aAAa,GAAG,CAAC,CAAC;AAExB;;;;;;;GAOG;AACH,SAAsB,OAAO,CAA0C,IAAqD,EAAE,SAA8C,EAAE,OAAwB;IAAE,uBAA+B;SAA/B,UAA+B,EAA/B,qBAA+B,EAA/B,IAA+B;QAA/B,sCAA+B;;;;;;;oBAClO,aAAa,GAAG,CAAC,CAAC;oBAChB,WAAW,GAAG,CAAA,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,gBAAgB,KAAI,kBAAkB,CAAC;oBAC9D,YAAY,GAAG,CAAA,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,KAAK,KAAI,KAAK,CAAC;oBACvC,QAAQ,GAAG,CAAA,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,QAAQ,KAAI,SAAS,CAAC;oBAC1C,YAAY,GAAG,CAAA,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,YAAY,KAAI,aAAa,CAAC;;;yBACrD,CAAA,aAAa,GAAG,WAAW,CAAA;oBAC3B,eAAe,GAAG,YAAY,GAAG,IAAI,CAAC,GAAG,CAAC,YAAY,EAAE,aAAa,CAAC,CAAC;oBACvE,SAAS,GAAG,IAAI,CAAC,GAAG,CAAC,eAAe,EAAE,QAAQ,CAAC,CAAC;oBACtD,qBAAM,IAAA,aAAK,EAAC,SAAS,CAAC,EAAA;;oBAAtB,SAAsB,CAAC;;;;oBAES,qBAAM,IAAI,eAAI,aAAa,GAAC;;oBAArD,UAAU,GAAe,SAA4B;oBACrD,eAAe,GAAG,SAAS,CAAC,UAAU,CAAC,CAAC;oBAC9C,IAAI,eAAe,IAAI,CAAC,CAAC,aAAa,GAAG,CAAC,GAAG,WAAW,CAAC;wBAAE,sBAAO,UAAU,EAAC;;;;;;oBAI9E,aAAa,EAAE,CAAC;;;;;;CAEjB;AAnBD,0BAmBC"}

package/dist/delay.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.delay = void 0;
+/**
+ * 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
+ */
+function delay(millis) {
+    return new Promise(function (resolve, _reject) { return setTimeout(resolve, millis); });
+}
+exports.delay = delay;
+//# sourceMappingURL=delay.js.map

package/dist/delay.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"delay.js","sourceRoot":"","sources":["../lib/delay.ts"],"names":[],"mappings":";;;AAAA;;;;;GAKG;AACH,SAAgB,KAAK,CAAC,MAAc;IACnC,OAAO,IAAI,OAAO,CAAC,UAAC,OAAO,EAAE,OAAO,IAAK,OAAA,UAAU,CAAC,OAAO,EAAE,MAAM,CAAC,EAA3B,CAA2B,CAAC,CAAC;AACvE,CAAC;AAFD,sBAEC"}

package/dist/handler.js

@@ -0,0 +1,82 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handler = void 0;
+var determineRetryableDynamo_1 = require("./aws-services/dynamodb/determineRetryableDynamo");
+var backOff_1 = require("./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
+ */
+function handler(err, task, evaluator) {
+    var taskArguments = [];
+    for (var _i = 3; _i < arguments.length; _i++) {
+        taskArguments[_i - 3] = arguments[_i];
+    }
+    return __awaiter(this, void 0, void 0, function () {
+        var canBeRetried, result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    canBeRetried = (0, determineRetryableDynamo_1.determineRetryableDynamo)(err);
+                    if (!canBeRetried) return [3 /*break*/, 2];
+                    return [4 /*yield*/, backOff_1.backoff.apply(void 0, __spreadArray([task, evaluator, undefined], taskArguments, false))];
+                case 1:
+                    result = _a.sent();
+                    return [2 /*return*/, result];
+                case 2: return [2 /*return*/, err];
+            }
+        });
+    });
+}
+exports.handler = handler;
+//# sourceMappingURL=handler.js.map

package/dist/handler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handler.js","sourceRoot":"","sources":["../lib/handler.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,6FAA4F;AAC5F,qCAAoC;AAEpC;;;;;;;;GAQG;AACH,SAAsB,OAAO,CAA0C,GAAY,EAAE,IAAuD,EAAE,SAA0C;IAAE,uBAA+B;SAA/B,UAA+B,EAA/B,qBAA+B,EAA/B,IAA+B;QAA/B,sCAA+B;;;;;;;oBAClN,YAAY,GAAG,IAAA,mDAAwB,EAAC,GAAG,CAAC,CAAC;yBAC/C,YAAY,EAAZ,wBAAY;oBACA,qBAAM,iBAAO,8BAAC,IAAI,EAAE,SAAS,EAAE,SAAS,GAAK,aAAa,WAAC;;oBAApE,MAAM,GAAG,SAA2D;oBAC1E,sBAAO,MAAM,EAAC;wBAEf,sBAAO,GAAG,EAAC;;;;CACX;AAPD,0BAOC"}

package/dist/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./aws-services/dynamodb/determineRetryableDynamo"), exports);
+__exportStar(require("./backOff"), exports);
+__exportStar(require("./handler"), exports);
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../lib/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,mFAAiE;AACjE,4CAA0B;AAC1B,4CAA0B"}

package/package.json

@@ -1,22 +1,26 @@
 {
 	"name": "@factorearth/recordmiddleware-errorhandler",
-	"version": "0.0.1-y.24",
+	"version": "0.0.1-y.26",
 	"description": "A module for handling CRUD errors in lambda",
 	"author": "madtrx <marlin.makori@gmail.com>",
 	"homepage": "https://github.com/FactorEarth/RecordMiddleware#readme",
 	"license": "ISC",
-	"main": "dist/index.js",
-	"types": "dist/index.d.ts",
+	"main": "dist/index",
+	"types": "dist/index",
 	"files": [
 		"dist"
 	],
+	"scripts": {
+		"build": "npm run clean && npm run compile",
+		"clean": "rm -rf ./dist && rm -rf tsconfig.build.tsbuildinfo",
+		"compile": "tsc -b tsconfig.build.json",
+		"test": "node ./__tests__/errorHandler.test.js",
+		"prepublishOnly": "npm run build"
+	},
 	"repository": {
 		"type": "git",
 		"url": "git+https://github.com/FactorEarth/RecordMiddleware.git"
 	},
-	"scripts": {
-		"test": "node ./__tests__/errorHandler.test.js"
-	},
 	"bugs": {
 		"url": "https://github.com/FactorEarth/RecordMiddleware/issues"
 	},
@@ -24,5 +28,5 @@
 		"access": "public",
 		"registry": "https://registry.npmjs.org/"
 	},
-	"gitHead": "49e25c03c2ba02f2613958c90e18e82173d5865a"
+	"gitHead": "df6f3f954d6db402b0dfe78dbfc386ba9684f824"
 }