smartystreets-javascript-sdk 1.13.7 → 2.0.0

package/Makefile

@@ -1,6 +1,6 @@
 #!/usr/bin/make -f
 
-VERSION           := $(shell tagit -p --dry-run)
+VERSION           := $(shell tagit -M --dry-run)
 VERSION_FILE1     := package.json
 VERSION_FILE2     := package-lock.json
 
@@ -11,7 +11,7 @@ node_modules:
 	npm install
 
 publish: test version upload unversion
-	tagit -p
+	tagit -M
 	git push origin --tags
 
 upload:

package/package.json

@@ -1,6 +1,6 @@
 {
  "name": "smartystreets-javascript-sdk",
- "version": "1.13.7",
+ "version": "2.0.0",
  "description": "Quick and easy Smarty address validation.",
  "keywords": [
   "smarty",
@@ -32,8 +32,8 @@
   "url": "github:smartystreets/smartystreets-javascript-sdk"
  },
  "devDependencies": {
-  "chai": "^4.2.0",
-  "mocha": "^9.2.1"
+  "chai": "^4.3.6",
+  "mocha": "^9.2.2"
  },
  "dependencies": {
   "axios": "^0.26.1",

package/src/ClientBuilder.js

@@ -8,6 +8,8 @@ const CustomHeaderSender = require("./CustomHeaderSender");
 const StatusCodeSender = require("./StatusCodeSender");
 const LicenseSender = require("./LicenseSender");
 const BadCredentialsError = require("./Errors").BadCredentialsError;
+const RetrySender = require("./RetrySender.js");
+const Sleeper = require("./util/Sleeper.js");
 
 //TODO: refactor this to work more cleanly with a bundler.
 const UsStreetClient = require("./us_street/Client");
@@ -151,10 +153,14 @@ class ClientBuilder {
 	buildSender() {
 		if (this.httpSender) return this.httpSender;
 
-		const httpSender = new HttpSender(this.maxTimeout, this.maxRetries, this.proxy, this.debug);
+		const httpSender = new HttpSender(this.maxTimeout, this.proxy, this.debug);
 		const statusCodeSender = new StatusCodeSender(httpSender);
 		const signingSender = new SigningSender(statusCodeSender, this.signer);
-		const agentSender = new AgentSender(signingSender);
+		let agentSender = new AgentSender(signingSender);
+		if (this.maxRetries > 0) {
+			const retrySender = new RetrySender(this.maxRetries, signingSender, new Sleeper());
+			agentSender = new AgentSender(retrySender);
+		}
 		const customHeaderSender = new CustomHeaderSender(agentSender, this.customHeaders);
 		const baseUrlSender = new BaseUrlSender(customHeaderSender, this.baseUrl);
 		const licenseSender = new LicenseSender(baseUrlSender, this.licenses);

package/src/HttpSender.js

@@ -1,12 +1,9 @@
 const Response = require("./Response");
 const Axios = require("axios");
-const axiosRetry = require("axios-retry");
+const {buildSmartyResponse} = require("../src/util/buildSmartyResponse");
 
 class HttpSender {
-	constructor(timeout = 10000, retries = 5, proxyConfig, debug = false) {
-		axiosRetry(Axios, {
-			retries: retries,
-		});
+	constructor(timeout = 10000, proxyConfig, debug = false) {
 		this.timeout = timeout;
 		this.proxyConfig = proxyConfig;
 		if (debug) this.enableDebug();
@@ -33,24 +30,19 @@ class HttpSender {
 		return config;
 	}
 
-	buildSmartyResponse(response, error) {
-		if (response) return new Response(response.status, response.data);
-		return new Response(undefined, undefined, error)
-	}
-
 	send(request) {
 		return new Promise((resolve, reject) => {
 			let requestConfig = this.buildRequestConfig(request);
 
 			Axios(requestConfig)
 				.then(response => {
-					let smartyResponse = this.buildSmartyResponse(response);
+					let smartyResponse = buildSmartyResponse(response);
 
 					if (smartyResponse.statusCode >= 400) reject(smartyResponse);
 
 					resolve(smartyResponse);
 				})
-				.catch(error => reject(this.buildSmartyResponse(undefined, error)));
+				.catch(error => reject(buildSmartyResponse(undefined, error)));
 		});
 	}
 

package/src/Response.js

@@ -1,8 +1,9 @@
 class Response {
-	constructor (statusCode, payload, error = undefined) {
+	constructor (statusCode, payload, error, headers) {
 		this.statusCode = statusCode;
 		this.payload = payload;
 		this.error = error;
+		this.headers = headers;
 	}
 }
 

package/src/RetrySender.js

@@ -0,0 +1,50 @@
+class RetrySender {
+	constructor(maxRetires = 5, inner, sleeper) {
+		this.maxRetries = maxRetires;
+		this.statusToRetry = [408, 429, 500, 502, 503, 504];
+		this.statusTooManyRequests = 429;
+		this.maxBackoffDuration = 10;
+		this.inner = inner;
+		this.sleeper = sleeper;
+	}
+
+	async send(request) {
+		let response = await this.inner.send(request);
+
+		for (let i = 0; i < this.maxRetries; i++) {
+
+			if (!this.statusToRetry.includes(parseInt(response.statusCode))) {
+				break;
+			}
+
+			if (parseInt(response.statusCode) === this.statusTooManyRequests) {
+				let secondsToBackoff = 10;
+				if (response.headers) {
+					const retryAfterHeader = response.headers["Retry-After"];
+					if (Number.isInteger(retryAfterHeader)) {
+						secondsToBackoff = retryAfterHeader;
+					}
+				}
+				await this.rateLimitBackOff(secondsToBackoff);
+			} else {
+				await this.backoff(i);
+			}
+			response = await this.inner.send(request);
+		}
+
+		return response;
+	};
+
+	async backoff(attempt) {
+		const backoffDuration = Math.min(attempt, this.maxBackoffDuration);
+		console.log(`There was an error processing the request. Retrying in ${backoffDuration} seconds...`);
+		await this.sleeper.sleep(backoffDuration);
+	};
+
+	async rateLimitBackOff(backoffDuration) {
+		console.log(`Rate limit reached. Retrying in ${backoffDuration} seconds...`);
+		await this.sleeper.sleep(backoffDuration);
+	};
+}
+
+module.exports = RetrySender;

package/src/util/Sleeper.js

@@ -0,0 +1,8 @@
+class Sleeper {
+	constructor () {}
+	sleep(seconds) {
+		return new Promise(resolve => setTimeout(resolve, seconds*1000));
+	}
+}
+
+module.exports = Sleeper;

package/src/util/buildSmartyResponse.js

@@ -0,0 +1,10 @@
+const Response = require("../Response.js");
+
+function buildSmartyResponse(response, error) {
+	if (response) return new Response(response.status, response.data, response.error, response.headers);
+	return new Response(undefined, undefined, error)
+}
+
+module.exports = {
+	buildSmartyResponse
+};

package/tests/fixtures/MockSleeper.js

@@ -0,0 +1,10 @@
+class MockSleeper {
+	constructor() {
+		this.sleepDurations = [];
+	}
+	sleep(ms) {
+		this.sleepDurations.push(ms);
+	}
+}
+
+module.exports = MockSleeper;

package/tests/fixtures/mock_senders.js

@@ -1,3 +1,4 @@
+const {buildSmartyResponse} = require("../../src/util/buildSmartyResponse.js");
 const Response = require("../../src/Response");
 
 module.exports = {
@@ -20,4 +21,21 @@ module.exports = {
 			});
 		}
 	},
-};
+	MockSenderWithStatusCodesAndHeaders: function (statusCodes, headers = undefined, error = undefined) {
+		this.statusCodes = statusCodes;
+		this.headers = headers;
+		this.error = error;
+		this.currentStatusCodeIndex = 0;
+
+		this.send = function (request) {
+			let mockResponse = {
+				status: this.statusCodes[this.currentStatusCodeIndex],
+				headers: this.headers,
+				error: this.error,
+			};
+			const response = buildSmartyResponse(mockResponse);
+			this.currentStatusCodeIndex += 1;
+			return response;
+		}
+	}
+};

package/tests/test_HttpSender.js

@@ -2,6 +2,7 @@ const chai = require("chai");
 const expect = chai.expect;
 const Request = require("../src/Request");
 const HttpSender = require("../src/HttpSender");
+const {buildSmartyResponse} = require("../src/util/buildSmartyResponse");
 
 describe ("An Axios implementation of a HTTP sender", function () {
 	it("adds a data payload to the HTTP request config.", function () {
@@ -71,7 +72,7 @@ describe ("An Axios implementation of a HTTP sender", function () {
 		let mockResponse = {
 			status: 200
 		};
-		let smartyResponse = sender.buildSmartyResponse(mockResponse);
+		let smartyResponse = buildSmartyResponse(mockResponse);
 
 		expect(smartyResponse.hasOwnProperty("statusCode")).to.equal(true);
 		expect(smartyResponse.statusCode).to.equal(200);
@@ -84,7 +85,7 @@ describe ("An Axios implementation of a HTTP sender", function () {
 			status: 200,
 			data: mockData
 		};
-		let smartyResponse = sender.buildSmartyResponse(mockResponse);
+		let smartyResponse = buildSmartyResponse(mockResponse);
 
 		expect(smartyResponse.hasOwnProperty("payload")).to.equal(true);
 		expect(smartyResponse.payload).to.equal(mockData);

package/tests/test_RetrySender.js

@@ -0,0 +1,98 @@
+const chai = require("chai");
+const expect = chai.expect;
+const RetrySender = require("../src/RetrySender");
+const {MockSenderWithStatusCodesAndHeaders} = require("./fixtures/mock_senders");
+const Request = require("../src/Request.js");
+const MockSleeper = require("./fixtures/MockSleeper.js");
+
+async function sendWithRetry(retries, inner, sleeper) {
+	const request = new Request();
+	const sender = new RetrySender(retries, inner, sleeper);
+	return await sender.send(request);
+}
+
+describe ("Retry Sender tests", function () {
+	it("test success does not retry", async function () {
+		let inner = new MockSenderWithStatusCodesAndHeaders(["200"]);
+		await sendWithRetry(5, inner, new MockSleeper());
+
+		expect(inner.currentStatusCodeIndex).to.equal(1);
+	});
+
+	it("test client error does not retry", async function () {
+		let inner = new MockSenderWithStatusCodesAndHeaders(["422"]);
+		await sendWithRetry(5, inner, new MockSleeper());
+
+		expect(inner.currentStatusCodeIndex).to.equal(1);
+	});
+
+	it("test will retry until success", async function () {
+		let inner =  new MockSenderWithStatusCodesAndHeaders(["500", "500", "500", "200", "500"]);
+		await sendWithRetry(10, inner, new MockSleeper());
+
+		expect(inner.currentStatusCodeIndex).to.equal(4);
+	});
+
+	it("test return response if retry limit exceeded", async function () {
+		let inner = new MockSenderWithStatusCodesAndHeaders(["500", "500", "500", "500", "500"]);
+		const sleeper = new MockSleeper();
+		const response = await sendWithRetry(4, inner, sleeper);
+
+		expect(response);
+		expect(inner.currentStatusCodeIndex).to.equal(5);
+		expect(response.statusCode).to.equal("500");
+		expect(sleeper.sleepDurations).to.deep.equal([0, 1, 2, 3]);
+	});
+
+	it("test backoff does not exceed max", async function () {
+		let inner = new MockSenderWithStatusCodesAndHeaders(["500", "500", "500", "500", "500", "500", "500", "500", "500", "500", "500", "500", "500", "200"]);
+		const sleeper = new MockSleeper();
+
+		await sendWithRetry(20, inner, sleeper);
+
+		expect(sleeper.sleepDurations).to.deep.equal([0,1,2,3,4,5,6,7,8,9,10,10,10]);
+	});
+
+	it("test empty status does not retry", async function () {
+		let inner = new MockSenderWithStatusCodesAndHeaders([]);
+		await sendWithRetry(5, inner, new MockSleeper());
+
+		expect(inner.currentStatusCodeIndex).to.equal(1);
+	});
+
+	it("test sleep on rate limit", async function () {
+		let inner = new MockSenderWithStatusCodesAndHeaders(["429", "200"]);
+		const sleeper = new MockSleeper();
+
+		await sendWithRetry(5, inner, sleeper);
+
+		expect(sleeper.sleepDurations).to.deep.equal([10]);
+	});
+
+	it("test rate limit error return", async function () {
+		let inner = new MockSenderWithStatusCodesAndHeaders(["429"], {"Retry-After": 7});
+		const sleeper = new MockSleeper();
+
+		await sendWithRetry(10, inner, sleeper);
+
+		expect(sleeper.sleepDurations).to.deep.equal([7]);
+	});
+
+	it("test retry after invalid value", async function () {
+		let inner = new MockSenderWithStatusCodesAndHeaders(["429"], {"Retry-After": "a"});
+		const sleeper = new MockSleeper();
+
+		await sendWithRetry(10, inner, sleeper);
+
+		expect(sleeper.sleepDurations).to.deep.equal([10]);
+	});
+
+	it("test retry error", async function () {
+		let inner = new MockSenderWithStatusCodesAndHeaders(["429"], undefined, "Big Bad");
+		const sleeper = new MockSleeper();
+
+		const response = await sendWithRetry(10, inner, sleeper);
+
+		expect(response.error).to.equal("Big Bad");
+	});
+});