Re-organize the codes

Author: joyqi

.mocharc.yml

@@ -1,6 +1,4 @@
 extension: ['ts', 'tsx'] # add tsx if you use react
 spec: 'src/**/*.spec.ts'
 require: 'ts-node/register'
-timeout: '3000'
-file:
-  - 'src/pretest.ts'
+timeout: '3000'

README.md

@@ -6,4 +6,20 @@ This is a Node.js library for [Dan](https://dan.com/) api.
 
 ```bash
 npm install dan-api
+```
+
+## Usage
+
+```js
+const DanApi = require('dan-api');
+
+const api = new DanApi({
+    token: 'YOUR_TOKEN',
+    timeout: 10000,
+    sandbox: false,
+});
+
+(async () => {
+    console.log(await api.dp.search('dan'));
+})();
 ```

src/api/dp.spec.ts

@@ -1,4 +1,4 @@
-import { request } from "../endpoint";
+import DanApi from "../constructor";
 
 type BuyAmount = {
     value: number;
@@ -39,7 +39,11 @@ type Domain = {
 }
 
 // Search distribution network for domain
-export async function search(query: string) {
-    const { results } = await request('/dp/demand/domains', 'GET', { query });
-    return results as Domain[];
+export function dp(api: DanApi) {
+    async function search(query: string) {
+        const { results } = await api.endpoint.request('/dp/demand/domains', 'GET', { query });
+        return results as Domain[];
+    }
+
+    return { search };
 }

src/api/dp.ts

@@ -0,0 +1,42 @@
+import axios from "axios";
+import DanApi from "./constructor";
+
+type TokenResponse = {
+    token: string;
+    expires_at: number;
+};
+
+export function auth(api: DanApi) {
+    const tokenCache: Partial<TokenResponse> = {};
+
+    // Request a dan auth token, store it in cache
+    // If the token is expired, request a new one
+    async function token(): Promise<string> {
+        if (tokenCache.token && tokenCache.expires_at && tokenCache.expires_at > Date.now()) {
+            return tokenCache.token;
+        }
+
+        const response = await axios.post(
+            api.endpoint.url('/tokens'),
+            {
+                integrator_token: api.getIntegratorToken()
+            },
+            {
+                timeout: api.getTimeOut(),
+            }
+        );
+
+        if (response.status !== 200) {
+            throw new Error('Token error');
+        }
+
+        const data: TokenResponse = response.data;
+
+        tokenCache.token = data.token;
+        tokenCache.expires_at = data.expires_at;
+
+        return data.token;
+    }
+
+    return { token };
+}

src/auth.ts

@@ -0,0 +1,51 @@
+import { dp } from "./api/dp";
+import { auth } from "./auth";
+import { endpoint } from "./endpoint";
+
+// Configuration for dan api
+export type DanConfig = {
+    token?: string;
+    sandbox: boolean;
+    timeout?: number;
+};
+
+// Dan api constructor
+export default class DanApi {
+    private integratorToken: string;
+    private sandbox: boolean;
+    private timeout: number;
+
+    public endpoint: ReturnType<typeof endpoint>;
+    public auth: ReturnType<typeof auth>;
+    public dp: ReturnType<typeof dp>;
+
+    // Set the configuration
+    constructor(config: DanConfig) {
+        this.integratorToken = config.token || '';
+        this.sandbox = config.sandbox;
+        this.timeout = config.timeout || 3000;
+
+        this.endpoint = endpoint(this);
+        this.auth = auth(this);
+        this.dp = dp(this);
+    }
+
+    // Get integrator token
+    getIntegratorToken(): string {
+        if (!this.integratorToken) {
+            throw new Error('Integrator token not set');
+        }
+
+        return this.integratorToken;
+    }
+
+    // Get sandbox mode
+    isSandbox(): boolean {
+        return this.sandbox;
+    }
+
+    // Get timeout
+    getTimeOut(): number {
+        return this.timeout;
+    }
+}

src/constructor.ts

@@ -1,32 +1,35 @@
 import axios, { Method } from "axios";
-import { getAuthToken } from "./token";
-import { getTimeOut, isSandbox } from "./init";
+import DanApi from "./constructor";
 
 const endpoints = {
     sandbox: 'https://sandbox.dan.com/api/integrator/v1',
     production: 'https://dan.com/api/integrator/v1'
 };
 
-// Get the url of the endpoint
-export function endpointUrl(path: string): string {
-    return `${endpoints[isSandbox() ? 'sandbox' : 'production']}${path}`;
-}
+export function endpoint(api: DanApi) {
+    // Get the url of the endpoint
+    function url(path: string): string {
+        return `${endpoints[api.isSandbox() ? 'sandbox' : 'production']}${path}`;
+    }
+
+    // Request the endpoint
+    async function request(path: string, method: Method, data?: any) {
+        const response = await axios({
+            method,
+            url: url(path),
+            data,
+            timeout: api.getTimeOut(),
+            headers: {
+                Authorization: 'Bearer ' + (await api.auth.token())
+            }
+        });
 
-// Request the endpoint
-export async function request(path: string, method: Method, data?: any) {
-    const response = await axios({
-        method,
-        url: endpointUrl(path),
-        data,
-        timeout: getTimeOut(),
-        headers: {
-            Authorization: 'Bearer ' + (await getAuthToken())
+        if (response.status !== 200) {
+            throw new Error('Endpoint error');
         }
-    });
 
-    if (response.status !== 200) {
-        throw new Error('Endpoint error');
+        return response.data;
     }
 
-    return response.data;
+    return { url, request };
 }

src/endpoint.spec.ts

@@ -0,0 +1,27 @@
+import DanApi from ".";
+import assert from "assert";
+import { describe } from "mocha";
+
+const api = new DanApi({
+    token: process.env.TOKEN,
+    sandbox: true,
+});
+
+describe("Endpoint", () => {
+    it("should return the correct url", () => {
+        assert.strictEqual(api.endpoint.url("/test"), "https://sandbox.dan.com/api/integrator/v1/test");
+    });
+});
+
+describe("Token", () => {
+    it("should return the correct token", async () => {
+        await api.auth.token();
+    });
+});
+
+describe("Distribution Network, Domains", () => {
+    it("should return the correct domain", async () => {
+        const domains = await api.dp.search("dan");
+        assert.ok(domains.length > 0, 'No domains found');
+    });
+});

src/endpoint.ts

@@ -1 +1,2 @@
-export { init as initDan } from './init'
+import DanApi from './constructor';
+export default DanApi;