Merge pull request #23 from truework/beta

[Beta] multiple hooks, deep merge options

Author: estrattonbailey

README.md

@@ -218,6 +218,10 @@ const { url, status, response } = await gretch(
 are good for code that needs to run on every request, like adding tracking
 headers and logging errors.
 
+Hooks should be defined as an array. That way you can compose multiple hooks
+per-request, and define and merge default hooks when [creating
+instances](#creating-instances).
+
 #### `before`
 
 The `before` hook runs just prior to the request being made. You can even modify
@@ -227,24 +231,29 @@ object, and the full options object.
 ```js
 const response = await gretch('/api/user/12', {
   hooks: {
-    before (request, options) {
-      request.headers.set('Tracking-ID', 'abcde')
-    }
+    before: [
+      (request, options) => {
+        request.headers.set('Tracking-ID', 'abcde')
+      }
+    ]
   }
 }).json()
 ```
 
 #### `after`
 
-The `after` hook has the opportunity to read the `gretchen` response. It
+The `after` runs after the request has resolved and any body interface methods
+have been called. It has the opportunity to read the `gretchen` response. It
 _cannot_ modify it. This is mostly useful for logging.
 
 ```js
 const response = await gretch('/api/user/12', {
   hooks: {
-    after ({ url, status, data, error }) {
-      sentry.captureMessage(`${url} returned ${status}`)
-    }
+    after: [
+      ({ url, status, data, error }, options) => {
+        sentry.captureMessage(`${url} returned ${status}`)
+      }
+    ]
   }
 }).json()
 ```

index.ts

@@ -6,10 +6,18 @@ import {
 } from './lib/handleRetry'
 import { handleTimeout } from './lib/handleTimeout'
 import { normalizeURL } from './lib/utils'
+import { merge } from './lib/merge'
 
 export type DefaultGretchResponse = any
 export type DefaultGretchError = any
 
+export type MergeableObject =
+  | {
+      [k: string]: MergeableObject
+    }
+  | Partial<GretchOptions>
+  | any[]
+
 export type GretchResponse<T = DefaultGretchResponse, A = DefaultGretchError> =
   | {
       url: string
@@ -26,9 +34,15 @@ export type GretchResponse<T = DefaultGretchResponse, A = DefaultGretchError> =
       response: Response
     }
 
+export type GretchBeforeHook = (request: Request, opts: GretchOptions) => void
+export type GretchAfterHook = (
+  response: GretchResponse,
+  opts: GretchOptions
+) => void
+
 export type GretchHooks = {
-  before?: (request: Request, opts: GretchOptions) => void
-  after?: (response: GretchResponse, opts: GretchOptions) => void
+  before?: GretchBeforeHook | GretchBeforeHook[]
+  after?: GretchAfterHook | GretchAfterHook[]
 }
 
 export type GretchOptions = {
@@ -89,7 +103,7 @@ export function gretch<T = DefaultGretchResponse, A = DefaultGretchError> (
     baseURL !== undefined ? normalizeURL(url, { baseURL }) : url
   const request = new Request(normalizedURL, options)
 
-  if (hooks.before) hooks.before(request, opts)
+  if (hooks.before) [].concat(hooks.before).forEach(hook => hook(request, opts))
 
   const fetcher = () =>
     timeout
@@ -144,7 +158,8 @@ export function gretch<T = DefaultGretchResponse, A = DefaultGretchError> (
         response
       }
 
-      if (hooks.after) hooks.after(res, opts)
+      if (hooks.after)
+        [].concat(hooks.after).forEach(hook => hook({ ...res }, opts))
 
       return res
     }
@@ -158,6 +173,6 @@ export function create (defaultOpts: GretchOptions = {}) {
     T = DefaultGretchResponse,
     A = DefaultGretchError
   > (url: string, opts: GretchOptions = {}): GretchInstance<T, A> {
-    return gretch(url, { ...defaultOpts, ...opts })
+    return gretch(url, merge(defaultOpts, opts))
   }
 }

lib/merge.ts

@@ -0,0 +1,41 @@
+import { GretchOptions, MergeableObject } from '../index'
+
+function headersToObj (headers: Headers) {
+  let o = {}
+
+  headers.forEach((v, k) => {
+    o[k] = v
+  })
+
+  return o
+}
+
+export function merge (
+  a: MergeableObject = {},
+  b: MergeableObject = {}
+): GretchOptions {
+  let c = { ...a }
+
+  for (const k of Object.keys(b)) {
+    const v = b[k]
+
+    if (typeof v === 'object') {
+      if (k === 'headers') {
+        c[k] = merge(
+          headersToObj(new Headers(a[k])),
+          headersToObj(new Headers(v))
+        )
+      } else if (v.pop && a[k].pop) {
+        c[k] = [...(a[k] || []), ...v]
+      } else if (typeof a[k] === 'object' && !a[k].pop) {
+        c[k] = merge(a[k], v)
+      } else {
+        c[k] = v
+      }
+    } else {
+      c[k] = v
+    }
+  }
+
+  return c
+}

package.json

@@ -3,8 +3,8 @@
   "version": "1.2.0",
   "description": "Making fetch happen in Typescript.",
   "source": "index.ts",
-  "main": "dist/gretchen.cjs.js",
-  "modern": "dist/gretchen.esm.js",
+  "main": "dist/gretchen.js",
+  "modern": "dist/gretchen.modern.js",
   "module": "dist/gretchen.esm.js",
   "unpkg": "dist/gretchen.iife.js",
   "types": "dist/index.d.ts",

test/index.js

@@ -9,6 +9,7 @@ require('./utils.test').default(test, assert)
 require('./handleRetry.test').default(test, assert)
 require('./handleTimeout.test').default(test, assert)
 require('./index.test').default(test, assert)
+require('./merge.test').default(test, assert)
 
 process.on('unhandledRejection', e => {
   console.error(e)

test/index.test.ts

@@ -267,16 +267,25 @@ export default (test, assert) => {
         await gretch(`http://127.0.0.1:${port}`, {
           timeout: 50000,
           hooks: {
-            before (request) {
+            before (request, opts) {
+              assert(request.url)
+              assert(opts.timeout)
               hooks++
             },
-            after ({ status }) {
-              hooks++
-            }
+            after: [
+              (response, opts) => {
+                assert(response.status)
+                assert(opts.timeout)
+                hooks++
+              },
+              () => {
+                hooks++
+              }
+            ]
           }
         }).json()
 
-        assert(hooks === 2)
+        assert(hooks === 3)
 
         server.close()
 

test/merge.test.ts

@@ -0,0 +1,110 @@
+import { merge } from '../lib/merge'
+
+export default (test, assert) => {
+  test('merges primitives', () => {
+    const o = merge(
+      {
+        str: 'in',
+        bool: false,
+        int: 0,
+        arr: ['in'],
+        obj: {
+          prop: 'in'
+        }
+      },
+      {
+        str: 'out',
+        bool: true,
+        int: 1,
+        arr: ['out'],
+        obj: {
+          prop: 'out'
+        }
+      }
+    )
+
+    assert.equal(o.str, 'out')
+    assert.equal(o.bool, true)
+    assert.equal(o.int, 1)
+    assert.deepEqual(o.arr, ['in', 'out'])
+    assert.equal(o.obj.prop, 'out')
+  })
+
+  test('merges headers', () => {
+    const o = merge(
+      {
+        headers: new Headers({
+          'X-In': 'in',
+          'X-Header': 'in'
+        })
+      },
+      {
+        headers: {
+          'X-Out': 'out',
+          'X-Header': 'out'
+        }
+      }
+    )
+
+    assert.equal(o.headers['x-header'], 'out')
+    assert.equal(o.headers['x-in'], 'in')
+    assert.equal(o.headers['x-out'], 'out')
+  })
+
+  test('overwrites mixed values', () => {
+    const o = merge(
+      {
+        timeout: 100,
+        retry: false,
+        hooks: {
+          after () {}
+        }
+      },
+      {
+        timeout: 200,
+        retry: {
+          attempts: 3
+        },
+        hooks: {
+          after: [() => {}]
+        }
+      }
+    )
+
+    assert.equal(o.timeout, 200)
+    // @ts-ignore
+    assert.equal(o.retry.attempts, 3)
+    assert(Array.isArray(o.hooks.after))
+  })
+
+  test('merges hooks', () => {
+    const o = merge(
+      {
+        hooks: {
+          before () {}
+        }
+      },
+      {
+        hooks: {
+          after () {}
+        }
+      }
+    )
+
+    assert(typeof o.hooks.before === 'function')
+    assert(typeof o.hooks.after === 'function')
+  })
+
+  test('clones reference object', () => {
+    const defaults = {
+      prop: 'default'
+    }
+
+    const o = merge(defaults, {
+      prop: 'out'
+    })
+
+    assert.equal(defaults.prop, 'default')
+    assert.equal(o.prop, 'out')
+  })
+}