feat: add headers to requests

docs/modules/index.ts.md

@@ -12,6 +12,9 @@ Added in v0.1.0
 
 <h2 class="text-delta">Table of contents</h2>
 
+- [combinators](#combinators)
+  - [setHeader](#setheader)
+  - [setHeaders](#setheaders)
 - [constructors](#constructors)
   - [Request](#request)
   - [send](#send)
@@ -23,6 +26,28 @@ Added in v0.1.0
 
 ---
 
+# combinators
+
+## setHeader
+
+**Signature**
+
+```ts
+export declare const setHeader: (key: string, value: string) => (request: Request) => Request
+```
+
+Added in v0.1.1
+
+## setHeaders
+
+**Signature**
+
+```ts
+export declare const setHeaders: (headers: Record<string, string>) => (request: Request) => Request
+```
+
+Added in v0.1.1
+
 # constructors
 
 ## Request

package.json

@@ -10,7 +10,8 @@
   "types": "dist/index.d.ts",
   "sideEffects": false,
   "peerDependencies": {
-    "fp-ts": "^2.11.0"
+    "fp-ts": "^2.11.0",
+    "monocle-ts": "^2.3.0"
   },
   "devDependencies": {
     "@commitlint/cli": "^16.2.3",

src/index.ts

@@ -4,7 +4,11 @@
 import * as E from 'fp-ts/Either'
 import * as R from 'fp-ts/Reader'
 import * as RTE from 'fp-ts/ReaderTaskEither'
+import * as r from 'fp-ts/Record'
+import * as S from 'fp-ts/Semigroup'
 import * as TE from 'fp-ts/TaskEither'
+import { flow, pipe } from 'fp-ts/function'
+import * as L from 'monocle-ts/Lens'
 
 import ReaderTaskEither = RTE.ReaderTaskEither
 
@@ -74,3 +78,25 @@ export const Request: (method: string) => (url: string | { href: string }) => Re
  */
 export const send: (request: Request) => ReaderTaskEither<FetchEnv, Error, Response> = ([url, init]) =>
   R.asks(TE.tryCatchK(({ fetch }) => fetch(url, init), E.toError))
+
+// -------------------------------------------------------------------------------------
+// combinators
+// -------------------------------------------------------------------------------------
+
+/**
+ * @category combinators
+ * @since 0.1.1
+ */
+export const setHeaders: (headers: Record<string, string>) => (request: Request) => Request = b =>
+  pipe(
+    L.id<Request>(),
+    L.component(1),
+    L.prop('headers'),
+    L.modify(a => r.getUnionSemigroup(S.last<string>()).concat(a, b)),
+  )
+
+/**
+ * @category combinators
+ * @since 0.1.1
+ */
+export const setHeader: (key: string, value: string) => (request: Request) => Request = flow(r.singleton, setHeaders)

test-d/ts4.0/index.ts

@@ -2,7 +2,7 @@ import { pipe } from 'fp-ts/function'
 import nodeFetch from 'node-fetch'
 import * as _ from '../../src'
 
-declare const r1: _.Request
+declare const request: _.Request
 declare const string: string
 declare const url: URL
 
@@ -27,4 +27,18 @@ pipe(url, _.Request(string))
 //
 
 // $ExpectType ReaderTaskEither<FetchEnv, Error, Response>
-_.send(r1)
+_.send(request)
+
+//
+// setHeaders
+//
+
+// $ExpectType Request
+pipe(request, _.setHeaders({ foo: 'bar' }))
+
+//
+// setHeader
+//
+
+// $ExpectType Request
+pipe(request, _.setHeader('foo', 'bar'))

test/fc.ts

@@ -4,12 +4,12 @@ import * as _ from '../src'
 
 export * from 'fast-check'
 
-export const request = (): fc.Arbitrary<_.Request> =>
+export const request = ({ headers }: { headers?: Record<string, string> } = {}): fc.Arbitrary<_.Request> =>
   fc.tuple(
     fc.string(),
     fc.record({
       body: fc.option(fc.string(), { nil: undefined }),
-      headers: fc.dictionary(fc.string(), fc.string()),
+      headers: headers ? fc.constant(headers) : fc.dictionary(fc.string(), fc.string()),
       method: fc.string(),
     }),
   )

test/index.test.ts

@@ -59,4 +59,66 @@ describe('fetch-fp-ts', () => {
       })
     })
   })
+
+  describe('combinators', () => {
+    describe('setHeaders', () => {
+      test('when the headers do not exist', () => {
+        fc.assert(
+          fc.property(fc.request({ headers: {} }), fc.dictionary(fc.string(), fc.string()), (request, headers) => {
+            expect(_.setHeaders(headers)(request)).toStrictEqual([
+              request[0],
+              {
+                ...request[1],
+                headers,
+              },
+            ])
+          }),
+        )
+      })
+
+      test('when headers already exist', () => {
+        fc.assert(
+          fc.property(fc.request({ headers: { foo: 'bar' } }), request => {
+            expect(_.setHeaders({ foo: 'baz' })(request)).toStrictEqual([
+              request[0],
+              {
+                ...request[1],
+                headers: { foo: 'baz' },
+              },
+            ])
+          }),
+        )
+      })
+    })
+
+    describe('setHeader', () => {
+      test('when the header does not exist', () => {
+        fc.assert(
+          fc.property(fc.request({ headers: {} }), fc.string(), fc.string(), (request, key, value) => {
+            expect(_.setHeader(key, value)(request)).toStrictEqual([
+              request[0],
+              {
+                ...request[1],
+                headers: { [key]: value },
+              },
+            ])
+          }),
+        )
+      })
+
+      test('when the header already exists', () => {
+        fc.assert(
+          fc.property(fc.request({ headers: { foo: 'bar' } }), request => {
+            expect(_.setHeader('foo', 'baz')(request)).toStrictEqual([
+              request[0],
+              {
+                ...request[1],
+                headers: { foo: 'baz' },
+              },
+            ])
+          }),
+        )
+      })
+    })
+  })
 })