feat(Core Interface): Update to Version 2

Version 2 of core-interface includes breaking changes to improve load
and running time. This is achieved by reorganising the library to be
better tree-shakeable.

Helper methods (like lookupPostcode) and resources (like addresses,
udprn) are not included with the client. Now they are exported by the
library and require the client to be injected

BREAKING CHANGE:

- Package now exports a `defaults` object
- Client.defaults has been removed
- All client config is now stored in `client.config`
- All resources have been removed from the client. Instead retrieve
these from the library and inject the client. E.g.
`client.postcodes.retrieve` becomes `postcodes.retrieve(client, ...)`
- Helper methods (like lookupPostcode, ping) have been removed from the client.
Instead retrieve these from teh library and inject the client. E.g.
`client.lookupPostcode` becomes `lookupPostcode(client, ...)`

Author: mfilip

README.md

@@ -68,18 +68,20 @@ const client = new Client({ api_key: "iddqd" });
 #### Use
 
 ```javascript
-const addresses = await client.lookupPostcode({ postcode: "SW1A2AA" });
+import { lookupPostcode } from "@ideal-postcodes/core-node";
+
+const addresses = await lookupPostcode({ client, postcode: "SW1A2AA" });
 ```
 
 #### Catch Errors
 
 ```javascript
-const { IdpcRequestFailedError } = Client.errors;
+import { lookupAddress, errors } from "@ideal-postcodes/core-node";
 
 try {
-  await client.lookupAddress({ query: "10 downing street" });
+  await lookupAddress({ client, query: "10 downing street" });
 } catch (error) {
-  if (error instanceof IdpcRequestFailedError) {
+  if (error instanceof errors.IdpcRequestFailedError) {
     // IdpcRequestFailedError indicates a 402 response code
     // Possibly the key balance has been depleted
   }
@@ -138,9 +140,10 @@ For a complete list of client methods, including low level resource methods, ple
 Return addresses associated with a given `postcode`
 
 ```javascript
+import { lookupPostcode } from "@ideal-postcodes/core-node";
 const postcode = "id11qd";
 
-const addresses = await client.lookupPostcode({ postcode });
+const addresses = await lookupPostcode({ client, postcode });
 ```
 
 [Method options](https://core-interface.ideal-postcodes.dev/interfaces/lookuppostcodeoptions.html)
@@ -150,9 +153,10 @@ const addresses = await client.lookupPostcode({ postcode });
 Return addresses associated with a given `query`
 
 ```javascript
+import { lookupAddress } from "@ideal-postcodes/core-node";
 const query = "10 downing street sw1a";
 
-const addresses = await client.lookupAddress({ query });
+const addresses = await lookupAddress({ client, query });
 ```
 
 [Method options](https://core-interface.ideal-postcodes.dev/interfaces/lookupaddressoptions.html)
@@ -164,9 +168,9 @@ Return address for a given `udprn`
 Invalid UDPRN will return `null`
 
 ```javascript
+import { lookupUdprn } from "@ideal-postcodes/core-node";
 const udprn = 23747771;
-
-const address = await client.lookupUdprn({ udprn });
+const address = await lookupUdprn({ client, udprn });
 ```
 
 [Method options](https://core-interface.ideal-postcodes.dev/interfaces/lookupudprnoptions.html)

lib/client.ts

@@ -1,10 +1,6 @@
 import {
   Client as CoreInterface,
-  TLS,
-  API_URL,
-  VERSION,
-  TIMEOUT,
-  STRICT_AUTHORISATION,
+  Config
 } from "@ideal-postcodes/core-interface";
 import { Agent, GotConfig } from "./agent";
 
@@ -13,36 +9,7 @@ import { Agent, GotConfig } from "./agent";
  */
 const USER_AGENT = `IdealPostcodes ideal-postcodes/core-node`;
 
-export interface Config {
-  /**
-   * Use TLS. Defaults to `true`
-   */
-  tls?: boolean;
-  /**
-   * API Key. Used in API helper methods
-   */
-  api_key: string;
-  /**
-   * Target API hostname. Defaults to `'api.ideal-postcodes.co.uk'`
-   */
-  baseUrl?: string;
-  /**
-   * API version. Defaults to `'v1'`
-   */
-  version?: string;
-  /**
-   * Force autocomplete authorisation via HTTP headers only. Defaults to `false`
-   */
-  strictAuthorisation?: boolean;
-  /**
-   * Default time in ms before HTTP request timeout. Defaults to 10s (`10000`)
-   */
-  timeout?: number;
-  /**
-   * String map specifying default headers
-   */
-  header?: Record<string, string>;
-}
+export { Config };
 
 export class Client extends CoreInterface {
   /**
@@ -57,25 +24,6 @@ export class Client extends CoreInterface {
   constructor(config: Config, gotConfig: GotConfig = {}) {
     const agent = new Agent(gotConfig);
     const header = { "User-Agent": USER_AGENT };
-    const tls = config.tls === undefined ? TLS : config.tls;
-    const baseUrl = config.baseUrl === undefined ? API_URL : config.baseUrl;
-    const version = config.version === undefined ? VERSION : config.version;
-    const strictAuthorisation =
-      config.strictAuthorisation === undefined
-        ? STRICT_AUTHORISATION
-        : config.strictAuthorisation;
-    const timeout = config.timeout === undefined ? TIMEOUT : config.timeout;
-
-    const { api_key } = config;
-    const interfaceConfig = {
-      tls,
-      api_key,
-      baseUrl,
-      version,
-      strictAuthorisation,
-      timeout,
-      header: { ...header, ...config.header },
-    };
-    super({ agent, ...interfaceConfig });
+    super({ agent, ...{ ...config, ...{ header }} });
   }
 }

lib/index.ts

@@ -1,4 +1,16 @@
-import { Client } from "./client";
-import { Agent } from "./agent";
+/**
+ * @module Library Exports
+ */
 
-export { Client, Agent };
+/**
+ * Export core-interface helpers and resources
+ *
+ */
+export * from "@ideal-postcodes/core-interface";
+
+/**
+ * Export HTTP Client with HTTP agent that supports got HTTP Client
+ */
+export { Client } from "./client";
+
+export { Agent } from "./agent";

package-lock.json

@@ -87,7 +87,7 @@
   },
   "license": "MIT",
   "dependencies": {
-    "@ideal-postcodes/core-interface": "~1.8.0",
+    "@ideal-postcodes/core-interface": "~2.0.1",
     "got": "~11.8.0"
   },
   "devDependencies": {

package.json

@@ -2,9 +2,9 @@ import * as sinon from "sinon";
 import { assert } from "chai";
 import { Agent, toHeader } from "../lib/agent";
 import { Response } from "got";
-import { Client } from "../lib/client";
+import { errors } from "../lib";
 
-const { IdealPostcodesError } = Client.errors;
+const { IdealPostcodesError } = errors;
 
 describe("Agent", () => {
   let agent: Agent;

test/agent.ts

@@ -2,13 +2,9 @@ import { assert } from "chai";
 import { Client, Config } from "../lib/client";
 import { Agent } from "../lib/agent";
 import {
-  TLS,
-  API_URL,
-  VERSION,
-  TIMEOUT,
-  STRICT_AUTHORISATION,
+  defaults,
   Config as InterfaceConfig,
-} from "@ideal-postcodes/core-interface";
+} from "../lib";
 
 describe("Client", () => {
   describe("instantiation", () => {
@@ -20,12 +16,12 @@ describe("Client", () => {
     });
 
     it("assigns default config values", () => {
-      assert.equal(client.api_key, api_key);
-      assert.equal(client.tls, TLS);
-      assert.equal(client.baseUrl, API_URL);
-      assert.equal(client.version, VERSION);
-      assert.equal(client.strictAuthorisation, STRICT_AUTHORISATION);
-      assert.equal(client.timeout, TIMEOUT);
+      assert.equal(client.config.api_key, api_key);
+      assert.equal(client.config.tls, defaults.tls);
+      assert.equal(client.config.baseUrl, defaults.baseUrl);
+      assert.equal(client.config.version, defaults.version);
+      assert.equal(client.config.strictAuthorisation, defaults.strictAuthorisation);
+      assert.equal(client.config.timeout, defaults.timeout);
     });
 
     it("allows default config values to be overwritten", () => {
@@ -38,26 +34,26 @@ describe("Client", () => {
         timeout: 2,
       };
       const customClient = new Client(options);
-      assert.equal(customClient.api_key, options.api_key);
-      assert.equal(customClient.tls, options.tls);
-      assert.equal(customClient.baseUrl, options.baseUrl);
-      assert.equal(customClient.version, options.version);
+      assert.equal(customClient.config.api_key, options.api_key);
+      assert.equal(customClient.config.tls, options.tls);
+      assert.equal(customClient.config.baseUrl, options.baseUrl);
+      assert.equal(customClient.config.version, options.version);
       assert.equal(
-        customClient.strictAuthorisation,
+        customClient.config.strictAuthorisation,
         options.strictAuthorisation
       );
-      assert.equal(customClient.timeout, options.timeout);
-      assert.deepEqual((customClient.agent as any).gotConfig, {});
+      assert.equal(customClient.config.timeout, options.timeout);
+      assert.deepEqual((customClient.config.agent as any).gotConfig, {});
     });
 
     it("assigns user agent header", () => {
-      assert.match(client.header["User-Agent"], /Core-Node/i);
+      assert.match(client.config.header["User-Agent"], /Core-Node/i);
     });
 
     it("assigns got config", () => {
       const retry = 2;
       const customClient = new Client({ api_key }, { retry });
-      assert.deepEqual((customClient.agent as any).gotConfig, { retry });
+      assert.deepEqual((customClient.config.agent as any).gotConfig, { retry });
     });
   });
 

test/client.ts

@@ -1,5 +1,6 @@
 import { assert } from "chai";
 import { Client } from "../lib/client";
+import { errors, ping, lookupPostcode } from "../lib";
 import { loadHttpFixtures } from "./fixtures/index";
 
 loadHttpFixtures(__filename);
@@ -8,12 +9,12 @@ const SUCCESS = 200;
 
 const api_key = process.env.VALID_API_KEY || "iddqd";
 const client = new Client({ api_key });
-const { IdpcInvalidKeyError, IdpcRequestFailedError } = Client.errors;
+const { IdpcInvalidKeyError, IdpcRequestFailedError } = errors;
 
 describe("Client integration test", () => {
   describe("ping", () => {
     it("pings /", async () => {
-      const response = await client.ping();
+      const response = await ping(client);
       assert.equal(response.httpStatus, SUCCESS);
     });
   });
@@ -25,21 +26,21 @@ describe("Client integration test", () => {
   describe("lookupPostcode", () => {
     it("retrieves postcode", async () => {
       const postcode = "SW1A 2AA";
-      const addresses = await client.lookupPostcode({ postcode });
+      const addresses = await lookupPostcode({ client, postcode });
       assert.isTrue(addresses.length > 0);
       assert.equal(addresses[0].postcode, postcode);
     });
 
     it("returns empty array for invalid postcode", async () => {
       const postcode = "Definitely bogus";
-      const addresses = await client.lookupPostcode({ postcode });
+      const addresses = await lookupPostcode({ client, postcode });
       assert.deepEqual(addresses, []);
     });
 
     it("returns an error for limit breached", async () => {
       const postcode = "ID1 CLIP";
       try {
-        await client.lookupPostcode({ postcode });
+        await lookupPostcode({ client,  postcode });
       } catch (error) {
         assert.isTrue(error instanceof IdpcRequestFailedError);
         return;
@@ -50,7 +51,7 @@ describe("Client integration test", () => {
     it("returns an error for balance depleted", async () => {
       const postcode = "ID1 CHOP";
       try {
-        await client.lookupPostcode({ postcode });
+        await lookupPostcode({ client, postcode });
       } catch (error) {
         assert.isTrue(error instanceof IdpcRequestFailedError);
         return;
@@ -61,7 +62,7 @@ describe("Client integration test", () => {
     it("returns an error for invalid key", async () => {
       const postcode = "SW1A 2AA";
       try {
-        await client.lookupPostcode({ postcode, api_key: "badKey" });
+        await lookupPostcode({ client, postcode, api_key: "badKey" });
       } catch (error) {
         assert.isTrue(error instanceof IdpcInvalidKeyError);
         return;