make-fetch 2.3.4 → 3.1.0

package/README.md

@@ -7,8 +7,10 @@ Implement your own `fetch()` with node.js streams
 npm i --save make-fetch
 ```
 
+Basic example:
+
 ```javascript
-const makeFetch = require('make-fetch')
+import { makeFetch } from 'make-fetch'
 const fetch = makeFetch(async (request) => {
   const {
     url, // String representing request URL
@@ -20,11 +22,11 @@ const fetch = makeFetch(async (request) => {
   } = request
 
   return {
-    statusCode: 200, // Should specify the status code to send back
+    status: 200, // Should specify the status code to send back
     headers: { // Optional object mapping response header titles to values
       "something": "whatever"
     },
-    data: asyncIterator // Required async iterable for the response body, can be empty
+    body: asyncIterator // Required async iterable for the response body, can be empty
   }
 })
 
@@ -32,7 +34,66 @@ const response = await fetch('myscheme://whatever/foobar')
 console.log(await response.text())
 ```
 
-## Gotchas
+Routed example:
+
+```JavaScript
+
+import {makeRoutedFetch} from "make-fetch"
+
+const {fetch, router} = makeRoutedFetch()
+
+router.get('example://somehost/**', (request) => {
+  return {
+    body: "hello world",
+    headers: {example: "Whatever"}
+  }
+})
+
+// You can have wildcards in the protocol, hostname,
+// or individual segments in the pathname
+router.post('*://*/foo/*/bar/, () => {
+  return {body: 'Goodbye world'}
+})
+
+// Match first handler
+fetch('example://somehost/example/path/here')
+
+// Match second handler
+fetch('whatever://something/foo/whatever/bar/')
+
+```
+
+### API:
+
+`makeFetch(async (Request) => ResponseOptions) => fetch()`
+
+The main API is based on the handler which takes a standard [Request](https://developer.mozilla.org/en-US/docs/Web/API/Request) object, and must return options for constructing a response based on the [Response](https://developer.mozilla.org/en-US/docs/Web/API/Request/Request) constructor.
+
+Instead of having a separate parameter for the body and the response options, the fetch handler should return both in one object.
+
+This will then return a standard [fetch](https://developer.mozilla.org/en-US/docs/Web/API/fetch) API which takes request info, and returns responses.
+
+`makeRoutedFetch({onNotFound, onError}) => {router: Router, fetch}`
+
+If you want to have an easier way of routing different methods/hostnames/paths, you can use a routed make-fetch which can make it easier to register handlers for different routes.
+This will creat a Router, and a `fetch()` instance for that router.
+Handlers you add on the router will be useful to match URLs+methods from the fetch request and will use the matched handler to generate the response.
+You can optionally supply a `onNotFound` handler to be invoked if no other routes match.
+You can optionally supply a `onError` handler to be invoked when an error is thrown from your handlers which will take the `Error` instance and the `Request` instance as arguments.
+The default `onError` handler will print the stack trace to the body with a `500` status code.
+
+`router.add(method, urlPattern, handler) => Router`
+
+You can add routes for specific methods, and use URL patterns.
+Then you can pass in the same basic handler as in makeFetch.
+You can chain multiple add requests since the router returns itself when adding a route.
+
+`router.get/head/put/post/delete(urlPattern, handler) => Router`
+
+You can also use shorthands for methods with a similar API.
+
+`router.any(urlPattern, handler)`
+
+You can register handlers for any method.
 
-- The `response.body` is an Async Iterable of Buffer objects rather than a WHATWG ReadableStream
-- Eventually ReadableStream will become async iterable so you'll be able to iterate either normally
+For example `router.any('*://*/**', handler)` will register a handler that will be invoked on any method/protocol scheme/hostname/path.

package/index.js

@@ -1,122 +1,162 @@
-const Headers = require('fetch-headers')
-const getStatus = require('statuses')
-const bodyToIterator = require('fetch-request-body-to-async-iterator')
-const { TransformStream } = require('web-streams-polyfill/ponyfill/es6')
-
-module.exports = function makeFetch (handler) {
-  return async function fetch (resource, init = {}) {
-    if (!resource) throw new Error('Must specify resource')
-    if (typeof resource === 'string') {
-      return fetch({
-        ...(init || {}),
-        url: resource
-      })
-    } else if (resource instanceof URL) {
-      return fetch(resource.href, init)
+export const WILDCARD = '*'
+
+const MATCH_ORDER = ['method', 'protocol', 'hostname', 'pathname']
+
+export function makeFetch (handler, {
+  Request = globalThis.Request,
+  Response = globalThis.Response
+} = {}) {
+  return async function fetch (...requestOptions) {
+    const request = new Request(...requestOptions)
+
+    const { body = null, ...responseOptions } = await handler(request)
+
+    const response = new Response(body, responseOptions)
+
+    return response
+  }
+}
+
+export function makeRoutedFetch ({
+  onNotFound = DEFAULT_NOT_FOUND,
+  onError = DEFAULT_ON_ERROR
+} = {}) {
+  const router = new Router()
+
+  const fetch = makeFetch(async (request) => {
+    const route = router.route(request)
+    if (!route) {
+      return onNotFound(request)
+    }
+    try {
+      return route.handler(request)
+    } catch (e) {
+      return await onError(e, request)
     }
+  })
+
+  return { fetch, router }
+}
+
+export function DEFAULT_NOT_FOUND () {
+  return { status: 404, statusText: 'Invalid URL' }
+}
 
-    const {
-      session,
-      url,
-      headers: rawHeaders,
-      method: rawMethod,
-      body: rawBody,
-      referrer,
-      signal
-    } = resource
-
-    const headers = rawHeaders ? headersToObject(rawHeaders) : {}
-    const method = (rawMethod || 'GET').toUpperCase()
-    const body = rawBody ? bodyToIterator(rawBody, session) : null
-
-    const {
-      statusCode,
-      statusText: rawStatusText,
-      headers: rawResponseHeaders,
-      data
-    } = await handler({
-      url,
-      headers,
-      method,
-      body,
-      referrer,
-      signal
-    })
-
-    const responseHeaders = new Headers(rawResponseHeaders || {})
-    const statusText = rawStatusText || getStatus(statusCode)
-
-    return new FakeResponse(statusCode, statusText, responseHeaders, data, url)
+export function DEFAULT_ON_ERROR (e) {
+  return {
+    status: 500,
+    headers: {
+      'Content-Type': 'text/plain; charset=utf-8'
+    },
+    body: e.stack
   }
 }
 
-class FakeResponse {
-  constructor (status, statusText, headers, iterator, url) {
-    this.body = makeBody(iterator)
-    this.headers = headers
-    this.url = url
-    this.status = status
-    this.statusText = statusText
+export class Router {
+  constructor () {
+    this.routes = []
   }
 
-  get ok () {
-    return this.status && this.status < 400
+  get (url, handler) {
+    return this.add('GET', url, handler)
   }
 
-  get useFinalURL () {
-    return true
+  head (url, handler) {
+    return this.add('HEAD', url, handler)
   }
 
-  async arrayBuffer () {
-    const buffer = await collectBuffers(this.body)
-    const { byteOffset, length } = buffer
-    const end = byteOffset + length
-    return buffer.buffer.slice(buffer.byteOffset, end)
+  post (url, handler) {
+    return this.add('POST', url, handler)
   }
 
-  async text () {
-    const buffer = await collectBuffers(this.body)
-    return buffer.toString('utf-8')
+  put (url, handler) {
+    return this.add('PUT', url, handler)
   }
 
-  async json () {
-    return JSON.parse(await this.text())
+  delete (url, handler) {
+    return this.add('DELETE', url, handler)
   }
-}
 
-function makeBody (iterator) {
-  const { readable, writable } = new TransformStream();
-  (async () => {
-    try {
-      const writer = writable.getWriter()
-      try {
-        for await (const x of iterator) await writer.write(x)
-      } finally {
-        await writer.close()
-      }
-    } catch {
-      // There was some sort of unhandled error?
+  patch (url, handler) {
+    return this.add('PATCH', url, handler)
+  }
+
+  any (url, handler) {
+    return this.add(WILDCARD, url, handler)
+  }
+
+  add (method, url, handler) {
+    const parsed = new URL(url)
+    const { hostname, protocol, pathname } = parsed
+    const segments = pathname.slice(1).split('/')
+
+    const route = {
+      protocol,
+      method: method.toUpperCase(),
+      hostname,
+      segments,
+      handler
     }
-  })()
-  return readable
-}
 
-function headersToObject (headers) {
-  if (!headers) return {}
-  if (typeof headers.entries === 'function') {
-    const result = {}
-    for (const [key, value] of headers) {
-      result[key] = value
+    this.routes.push(route)
+    return this
+  }
+
+  route (request) {
+    for (const route of this.routes) {
+      let hasFail = false
+      for (const property of MATCH_ORDER) {
+        if (!matches(request, route, property)) {
+          hasFail = true
+        }
+      }
+      if (!hasFail) {
+        return route
+      }
     }
-    return result
-  } else return headersToObject(new Headers(headers || {}))
+    return null
+  }
 }
 
-async function collectBuffers (iterable) {
-  const all = []
-  for await (const buff of iterable) {
-    all.push(Buffer.from(buff))
+function matches (request, route, property) {
+  if (property === 'pathname') {
+    const routeSegments = route.segments
+    const { pathname } = new URL(request.url)
+    const requestSegments = pathname.slice(1).split('/')
+
+    let i = 0
+    while (true) {
+      const routeLast = i === (routeSegments.length - 1)
+      const requestLast = i === (requestSegments.length - 1)
+
+      const routeSegment = routeSegments[i]
+      const requestSegment = requestSegments[i]
+      const routeWild = routeSegment === WILDCARD
+      const matches = routeWild || (routeSegment === requestSegment)
+
+      if (routeLast) {
+        if (routeSegment === (WILDCARD + WILDCARD)) return true
+        if (requestLast) return matches
+        return false
+      } else if (requestLast) {
+        return false
+      }
+
+      if (!matches) return false
+      i++
+    }
+  } if (property === 'hostname') {
+    return areEqual(route.hostname, new URL(request.url).hostname)
+  } else if (property === 'protocol') {
+    return areEqual(route.protocol, new URL(request.url).protocol)
+  } else {
+    const routeProperty = route[property]
+    const requestProperty = request[property]
+    return areEqual(routeProperty, requestProperty)
   }
+}
 
-  return Buffer.concat(all)
+function areEqual (routeProperty, requestProperty) {
+  if (routeProperty === '*') return true
+  return routeProperty === requestProperty
 }

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "make-fetch",
-  "version": "2.3.4",
+  "version": "3.1.0",
   "description": "Implement your own `fetch()` with node.js streams",
   "main": "index.js",
+  "type": "module",
   "scripts": {
     "test": "node test",
     "lint": "standard --fix"
@@ -23,15 +24,8 @@
     "url": "https://github.com/RangerMauve/make-fetch/issues"
   },
   "homepage": "https://github.com/RangerMauve/make-fetch#readme",
-  "dependencies": {
-    "concat-stream": "^2.0.0",
-    "fetch-headers": "^2.0.0",
-    "fetch-request-body-to-async-iterator": "^1.0.3",
-    "statuses": "^2.0.0",
-    "web-streams-polyfill": "^3.0.0"
-  },
   "devDependencies": {
     "standard": "^17.0.0",
-    "tape": "^5.0.1"
+    "tape": "^5.6.1"
   }
 }

package/test.js

@@ -1,37 +1,51 @@
-const test = require('tape')
+import test from 'tape'
 
-const makeFetch = require('./')
+import { makeFetch, makeRoutedFetch } from './index.js'
 
-test('Kitchen sink', async (t) => {
-  try {
-    const fetch = makeFetch(({ url }) => {
-      return {
-        statusCode: 200,
-        headers: {
-          url
-        },
-        data: intoAsyncIterable(url)
-      }
-    })
+test('Basic makeFetch test', async (t) => {
+  const fetch = makeFetch(({ url }) => {
+    return {
+      status: 200,
+      statusText: 'OK',
+      headers: {
+        url
+      },
+      body: intoAsyncIterable(url)
+    }
+  })
 
-    const toFetch = 'example'
+  const toFetch = 'example://hostname/pathname'
 
-    const response = await fetch(toFetch)
+  const response = await fetch(toFetch)
 
-    t.ok(response.ok, 'response was OK')
+  t.ok(response.ok, 'response was OK')
 
-    const body = await response.text()
+  const body = await response.text()
 
-    t.equal(body, toFetch, 'got expected response body')
+  t.equal(body, toFetch, 'got expected response body')
 
-    t.equal(response.headers.get('url'), toFetch, 'got expected response headers')
+  t.equal(response.headers.get('url'), toFetch, 'got expected response headers')
 
-    t.equal(response.statusText, 'OK', 'got expected status text')
+  t.equal(response.statusText, 'OK', 'got expected status text')
 
-    t.end()
-  } catch (e) {
-    t.error(e)
-  }
+  t.end()
+})
+
+test('Basic router tests', async (t) => {
+  const { fetch, router } = makeRoutedFetch()
+
+  router.get('ipfs://localhost/ipfs/**', ({ url }) => {
+    return { body: url }
+  })
+
+  const toFetch = 'ipfs://localhost/ipfs/cidwould/gohere'
+  const response = await fetch(toFetch)
+
+  t.ok(response.ok, 'response was OK')
+
+  const body = await response.text()
+
+  t.equal(body, toFetch, 'got expected body')
 })
 
 async function * intoAsyncIterable (data) {

package/index.d.ts

@@ -1,74 +0,0 @@
-declare module 'make-fetch' {
-  export interface NormalizedRequest {
-    url: string
-    headers: RawHeaders
-    method: string
-    body: AsyncIterableIterator<Uint8Array>
-    referrer?: string
-
-    // Hard to add types for. 😂
-    signal?: any
-  }
-
-  export interface HandlerResponse {
-    statusCode?: number
-    statusText?: string
-    headers?: RawHeaders
-    data?: AsyncIterableIterator<Uint8Array | string>
-  }
-
-  export interface RawHeaders {
-    [name: string]: string | undefined
-  }
-
-  // TODO: Support actual fetch Headers
-  export interface Headers {
-    append(name: string, value: string) : void
-    delete(name: string) : void
-    entries() : IterableIterator<[string, string]>
-    get(name: string): string | undefined
-    has(name: string) : boolean
-    keys() : IterableIterator<string>
-    set(name: string, value: string) : void
-    values() : IterableIterator<string>
-  }
-
-  export interface Request {
-    // This is kind of a pain to document
-    session?: any
-    signal?: any
-
-    url?: string
-    headers?: Headers | RawHeaders
-    method?: string,
-    body?: string | Uint8Array | AsyncIterableIterator<Uint8Array|string>,
-    referrer?: string,
-  }
-
-  export interface Body {
-   // TODO: Fill this in
-  }
-
-  export interface Response {
-    url: string
-    headers: Headers
-    status: number
-    statusText: string
-    ok: boolean
-    useFinalURL: true
-    body: Body
-    arrayBuffer() : Promise<ArrayBuffer>
-    text(): Promise<string>
-    json(): Promise<any>
-  }
-
-  export interface Fetch {
-    (request: string | Request, info? : Request): Promise<Response>
-  }
-
-  export interface FetchHandler {
-    (request: NormalizedRequest): Promise<HandlerResponse>
-  }
-
-  export default function makeFetch(handler: FetchHandler) : Fetch
-}

package/tsconfig.json

@@ -1,11 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "es2018",
-    "moduleResolution": "node",
-    "module": "commonjs",
-    "lib": [      
-      "dom",
-      "es2018"
-    ]
-  }
-}