Add a region provider abstraction

Author: jeskew

packages/region-provider/.gitignore

@@ -0,0 +1,4 @@
+/node_modules/
+*.js
+*.js.map
+*.d.ts

packages/region-provider/__tests__/chain.ts

@@ -0,0 +1,42 @@
+import {chain} from "../lib/chain";
+import {fromString} from "../lib/fromString";
+
+describe('chain', () => {
+    it('should distill many credential providers into one', async () => {
+        const provider = chain(
+            fromString('foo'),
+            fromString('bar'),
+        );
+
+        expect(typeof await provider()).toBe('string');
+    });
+
+    it('should return the resolved value of the first successful promise', async () => {
+        const provider = chain(
+            () => Promise.reject(new Error('Move along')),
+            () => Promise.reject(new Error('Nothing to see here')),
+            fromString('foo')
+        );
+
+        expect(await provider()).toBe('foo');
+    });
+
+    it('should not invoke subsequent providers one resolves', async () => {
+        const providers = [
+            jest.fn(() => Promise.reject(new Error('Move along'))),
+            jest.fn(() => Promise.resolve('foo')),
+            jest.fn(() => fail('This provider should not be invoked'))
+        ];
+
+        expect(await chain(...providers)()).toBe('foo');
+        expect(providers[0].mock.calls.length).toBe(1);
+        expect(providers[1].mock.calls.length).toBe(1);
+        expect(providers[2].mock.calls.length).toBe(0);
+    });
+
+    it('should reject chains with no links', async () => {
+        await expect(chain()()).rejects.toMatchObject({
+            message: 'No providers in chain'
+        });
+    });
+});

packages/region-provider/__tests__/fromString.ts

@@ -0,0 +1,10 @@
+import {fromString} from '../lib/fromString';
+
+describe('fromString', () => {
+    it('should convert a string into a provider', async () => {
+        const region = 'region';
+        const provider = fromString(region);
+
+        await expect(provider()).resolves.toBe(region);
+    });
+});

packages/region-provider/__tests__/memoize.ts

@@ -0,0 +1,21 @@
+import {memoize} from "../lib/memoize";
+
+describe('memoize', () => {
+    it('should cache the resolved provider', async () => {
+        const provider = jest.fn(() => Promise.resolve('foo'));
+        const memoized = memoize(provider);
+
+        expect(await memoized()).toEqual('foo');
+        expect(provider.mock.calls.length).toBe(1);
+        expect(await memoized()).toEqual('foo');
+        expect(provider.mock.calls.length).toBe(1);
+    });
+
+    it('should always return the same promise', () => {
+        const provider = jest.fn(() => Promise.resolve('foo'));
+        const memoized = memoize(provider);
+        const result = memoized();
+
+        expect(memoized()).toBe(result);
+    });
+});

packages/region-provider/index.ts

@@ -0,0 +1,3 @@
+export * from './lib/chain';
+export * from './lib/fromString';
+export * from './lib/memoize';

packages/region-provider/lib/Provider.ts

@@ -0,0 +1,3 @@
+export interface Provider<T> {
+    (): Promise<T>;
+}

packages/region-provider/lib/chain.ts

@@ -0,0 +1,31 @@
+import {Provider} from "@aws/types";
+
+/**
+ * Compose a single credential provider function from multiple credential
+ * providers. The first provider in the argument list will always be invoked;
+ * subsequent providers in the list will be invoked in the order in which the
+ * were received if the preceding provider did not successfully resolve.
+ *
+ * If no providers were received or no provider resolves successfully, the
+ * returned promise will be rejected.
+ */
+export function chain<T>(
+    ...providers: Array<Provider<T>>
+): Provider<T> {
+    return () => {
+        providers = providers.slice(0);
+        let provider = providers.shift();
+        if (provider === undefined) {
+            return Promise.reject(new Error(
+                'No providers in chain'
+            ));
+        }
+
+        let promise = provider();
+        while (provider = providers.shift()) {
+            promise = promise.catch(provider);
+        }
+
+        return promise;
+    }
+}

packages/region-provider/lib/fromString.ts

@@ -0,0 +1,6 @@
+import {Provider} from '@aws/types';
+
+export function fromString(region: string): Provider<string> {
+    const promisified = Promise.resolve(region);
+    return () => promisified;
+}

packages/region-provider/lib/memoize.ts

@@ -0,0 +1,11 @@
+import {Provider} from "@aws/types";
+
+/**
+ * Decorates a provider function with static memoization. The underlying
+ * provider will be invoked once, and all invocations of the returned provider
+ * will return the same promise object.
+ */
+export function memoize<T>(provider: Provider<T>): Provider<T> {
+    let result = provider();
+    return () => result;
+}

packages/region-provider/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@aws/region-provider",
+  "version": "0.0.1",
+  "private": true,
+  "description": "AWS region provider core. Provides an abstraction for sourcing a region from one or more asynchronous sources",
+  "main": "index.js",
+  "scripts": {
+    "prepublishOnly": "tsc",
+    "pretest": "tsc",
+    "test": "jest"
+  },
+  "keywords": [
+    "aws",
+    "credentials"
+  ],
+  "author": "[email protected]",
+  "license": "Apache-2.0",
+  "dependencies": {
+    "@aws/types": "^0.0.1"
+  },
+  "devDependencies": {
+    "@types/jest": "^20.0.2",
+    "jest": "^20.0.4",
+    "typescript": "^2.3"
+  }
+}

packages/region-provider/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "target": "es5",
+    "declaration": true,
+    "strict": true,
+    "sourceMap": true,
+    "lib": [
+      "es5",
+      "es2015.promise"
+    ]
+  }
+}