make-fetch 3.1.2 → 3.2.0

package/index.js

@@ -1,29 +1,71 @@
-export const WILDCARD = '*'
+/** @typedef {ConstructorParameters<typeof globalThis.Response>[0] | AsyncIterable<string>} Body */
+/** @typedef {Response|ResponseInit & {body?: Body}} ResponseLike */
+/** @typedef {(request: Request) => ResponseLike|Promise<ResponseLike> } Handler */
+/** @typedef {(error: Error, request: Request) => ResponseLike } ErrorHandler */
+
+/**
+ * @typedef {object} Route
+ * @property {string} protocol
+ * @property {string} method
+ * @property {string} hostname
+ * @property {string[]} segments
+ * @property {Handler} handler
+*/
 
+/** @typedef {'pathname' | 'hostname' | 'protocol' | 'method'} MatchProperty */
+
+/** @type {MatchProperty[]} */
 const MATCH_ORDER = ['method', 'protocol', 'hostname', 'pathname']
 
+export const WILDCARD = '*'
+
+/**
+ * @param {Handler} handler
+ * @param {object} [options]
+ * @param {typeof globalThis.Request} [options.Request]
+ * @param {typeof globalThis.Response} [options.Response]
+ * @returns {typeof fetch}
+ */
 export function makeFetch (handler, {
   Request = globalThis.Request,
   Response = globalThis.Response
 } = {}) {
-  return async function fetch (...requestOptions) {
-    const request = new Request(...requestOptions)
+  return fetch
+
+  /** @type {typeof globalThis.fetch} */
+  async function fetch (...requestOptions) {
+    const isAlreadyRequest = requestOptions[0] instanceof Request
+    const request = isAlreadyRequest ? /** @type {Request} */(requestOptions[0]) : new Request(...requestOptions)
 
     const { body = null, ...responseOptions } = await handler(request)
 
+    // @ts-ignore You can use an AsyncIterable of strings for body
     const response = new Response(body, responseOptions)
 
     return response
   }
 }
 
+/**
+ *
+ * @param {object} [options]
+ * @param {Handler} [options.onNotFound]
+ * @param {ErrorHandler} [options.onError]
+ * @returns
+ */
 export function makeRoutedFetch ({
   onNotFound = DEFAULT_NOT_FOUND,
   onError = DEFAULT_ON_ERROR
 } = {}) {
   const router = new Router()
 
-  const fetch = makeFetch(async (request) => {
+  const fetch = makeFetch(handler)
+
+  /**
+   * @param {Request} request
+   * @returns {Promise<ResponseLike>}
+   */
+  async function handler (request) {
     const route = router.route(request)
     if (!route) {
       return onNotFound(request)
@@ -32,9 +74,10 @@ export function makeRoutedFetch ({
       const response = await route.handler(request)
       return response
     } catch (e) {
-      return await onError(e, request)
+      // Typescript is annoying
+      return await onError(/** @type {Error} */ (e), request)
     }
-  })
+  }
 
   return { fetch, router }
 }
@@ -43,6 +86,7 @@ export function DEFAULT_NOT_FOUND () {
   return { status: 404, statusText: 'Invalid URL' }
 }
 
+/** @type {ErrorHandler} */
 export function DEFAULT_ON_ERROR (e) {
   return {
     status: 500,
@@ -55,37 +99,86 @@ export function DEFAULT_ON_ERROR (e) {
 
 export class Router {
   constructor () {
-    this.routes = []
+    this.routes = /** @type {Route[]} */ ([])
   }
 
+  /**
+   *
+   * @param {string} url
+   * @param {Handler} handler
+   * @returns {Router}
+   */
   get (url, handler) {
     return this.add('GET', url, handler)
   }
 
+  /**
+   *
+   * @param {string} url
+   * @param {Handler} handler
+   * @returns {Router}
+   */
   head (url, handler) {
     return this.add('HEAD', url, handler)
   }
 
+  /**
+   *
+   * @param {string} url
+   * @param {Handler} handler
+   * @returns {Router}
+   */
   post (url, handler) {
     return this.add('POST', url, handler)
   }
 
+  /**
+   *
+   * @param {string} url
+   * @param {Handler} handler
+   * @returns {Router}
+   */
   put (url, handler) {
     return this.add('PUT', url, handler)
   }
 
+  /**
+   *
+   * @param {string} url
+   * @param {Handler} handler
+   * @returns {Router}
+   */
   delete (url, handler) {
     return this.add('DELETE', url, handler)
   }
 
+  /**
+   *
+   * @param {string} url
+   * @param {Handler} handler
+   * @returns {Router}
+   */
   patch (url, handler) {
     return this.add('PATCH', url, handler)
   }
 
+  /**
+   *
+   * @param {string} url
+   * @param {Handler} handler
+   * @returns {Router}
+   */
   any (url, handler) {
     return this.add(WILDCARD, url, handler)
   }
 
+  /**
+   *
+   * @param {string} method
+   * @param {string} url
+   * @param {Handler} handler
+   * @returns {Router}
+   */
   add (method, url, handler) {
     const parsed = new URL(url)
     const { hostname, protocol, pathname } = parsed
@@ -103,6 +196,11 @@ export class Router {
     return this
   }
 
+  /**
+   *
+   * @param {Request} request
+   * @returns {Route?}
+   */
   route (request) {
     for (const route of this.routes) {
       let hasFail = false
@@ -119,6 +217,13 @@ export class Router {
   }
 }
 
+/**
+ *
+ * @param {Request} request
+ * @param {Route} route
+ * @param {MatchProperty} property
+ * @returns
+ */
 function matches (request, route, property) {
   if (property === 'pathname') {
     const routeSegments = route.segments
@@ -150,7 +255,7 @@ function matches (request, route, property) {
     return areEqual(route.hostname, new URL(request.url).hostname)
   } else if (property === 'protocol') {
     return areEqual(route.protocol, new URL(request.url).protocol)
-  } else if(property === 'method') {
+  } else if (property === 'method') {
     return areEqual(route.method, request.method.toUpperCase())
   } else {
     const routeProperty = route[property]
@@ -159,6 +264,11 @@ function matches (request, route, property) {
   }
 }
 
+/**
+ * @param {string} routeProperty
+ * @param {string} requestProperty
+ * @returns
+ */
 function areEqual (routeProperty, requestProperty) {
   if (routeProperty === '*') return true
   return routeProperty === requestProperty

package/package.json

@@ -1,12 +1,14 @@
 {
   "name": "make-fetch",
-  "version": "3.1.2",
+  "version": "3.2.0",
   "description": "Implement your own `fetch()` with node.js streams",
   "main": "index.js",
   "type": "module",
   "scripts": {
     "test": "node test",
-    "lint": "standard --fix"
+    "lint": "standard --fix && tsc --noEmit",
+    "build": "tsc",
+    "preversion": "npm run lint && npm run build && npm run test"
   },
   "repository": {
     "type": "git",
@@ -25,7 +27,11 @@
   },
   "homepage": "https://github.com/RangerMauve/make-fetch#readme",
   "devDependencies": {
+    "@tsconfig/node20": "^20.1.8",
+    "@types/node": "^25.0.3",
+    "@types/tape": "^5.8.1",
     "standard": "^17.0.0",
-    "tape": "^5.6.1"
+    "tape": "^5.6.1",
+    "typescript": "^5.9.3"
   }
 }

package/test.js

@@ -31,6 +31,35 @@ test('Basic makeFetch test', async (t) => {
   t.end()
 })
 
+test('Basic makeFetch test with Request object', async (t) => {
+  const fetch = makeFetch(({ url }) => {
+    return {
+      status: 200,
+      statusText: 'OK',
+      headers: {
+        url
+      },
+      body: intoAsyncIterable(url)
+    }
+  })
+
+  const toFetch = new Request('example://hostname/pathname')
+
+  const response = await fetch(toFetch)
+
+  t.ok(response.ok, 'response was OK')
+
+  const body = await response.text()
+
+  t.equal(body, toFetch.url, 'got expected response body')
+
+  t.equal(response.headers.get('url'), toFetch.url, 'got expected response headers')
+
+  t.equal(response.statusText, 'OK', 'got expected status text')
+
+  t.end()
+})
+
 test('Basic router tests', async (t) => {
   const { fetch, router } = makeRoutedFetch()
 
@@ -48,6 +77,10 @@ test('Basic router tests', async (t) => {
   t.equal(body, toFetch, 'got expected body')
 })
 
+/**
+ * @param {string} data
+ * @returns {AsyncIterable<string>}
+ */
 async function * intoAsyncIterable (data) {
   yield data
 }

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+    "compilerOptions": {
+        "target": "es2022",
+        "module": "nodenext",
+        "checkJs": true,
+        "allowJs": true,
+        "declaration": true,
+        "emitDeclarationOnly": true,
+        "moduleResolution": "nodenext",
+        "outDir": "dist",
+    },
+    "extends": "@tsconfig/node20/tsconfig.json",
+    "files": ["./index.js","./test.js"],
+    "include": ["./index.js","./test.js"]
+}