hypercore-fetch 10.0.0 → 10.2.0

package/README.md

@@ -11,23 +11,35 @@ import * as SDK from 'hyper-sdk'
 // Create in-memory hyper-sdk instance
 const sdk = await SDK.create({storage: false})
 
+// Init
 const fetch = await makeFetch({
   sdk: true,
   writable: true
 })
 
-const someURL = `hyper://TODO_REAL_URL_HERE_PLEASE`
+// Download
+const someURL = `hyper://blog.mauve.moe/`
 
 const response = await fetch(someURL)
 
 const data = await response.text()
 
 console.log(data)
+
+const response = await fetch('hyper://localhost/example.txt', {
+  method: 'PUT',
+  body: 'Hello World'
+})
+
+// This is where the data got uploaded
+const location = response.headers.get('Location')
+// Clear the response body or else electron will flip out
+await response.text()
 ```
 
 ## API
 
-### `makeHyperFetch({sdk, writable=false, extensionMessages = writable, renderIndex}) => fetch()`
+### `makeHyperFetch({sdk, writable=false, extensionMessages = writable, renderIndex, onLoad, onDelete}) => fetch()`
 
 Creates a hypercore-fetch instance.
 
@@ -40,6 +52,10 @@ The `writable` flag toggles whether the `PUT`/`POST`/`DELETE` methods are availa
 `renderIndex` is an optional function to override the HTML index rendering functionality. By default it will make a simple page which renders links to files and folders within the directory.
 This function takes the `url`, `files` array and `fetch` instance as arguments.
 
+`onLoad` is an optional function that gets called whenever a site is loaded. It gets these arguments passed in: `(url: URL, writable: boolean, key?: string)`. The `key` gets specified on creation based on the name a user assigned it. Use this to track created drives and last access times (e.g. for clearing out old drives).
+
+`onDelete` is an optional function that gets called whenever a drive is purged from storage. Similar to `onLoad`, it gets called with a `URL` of the deleted site.
+
 After you've created it, `fetch` will behave like it does in [browsers](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API).
 
 ### Common Headers
@@ -100,6 +116,8 @@ In order to create a writable Hyperdrive with its own URL, you must first genera
 
 `NAME` can be any alphanumeric string which can be used for key generation in [Corestore](https://github.com/holepunchto/corestore).
 
+If you omit the `NAME`, it will use the name `default`.
+
 The response body will contain a `hyper://` URL with the new Hyperdrive.
 
 You can then use this with `PUT`/`DELETE` requests.
@@ -112,6 +130,8 @@ If you want to resolve the public key URL of a previously created Hyperdrive, yo
 
 `NAME` can be any alphanumeric string which can be used for key generation in [Corestore](https://github.com/holepunchto/corestore).
 
+If you omit the `NAME`, it will use the name `default`.
+
 The response body will contain a `hyper://` URL with the new Hyperdrive.
 
 You can then use this with `PUT`/`DELETE` requests.
@@ -126,7 +146,7 @@ flag.
 
 The `body` can be any of the options supported by the Fetch API such as a `String`, `Blob`, `FormData`, or `ReadableStream`.
 
-`NAME` can either be the 52 character [z32 encoded](https://github.com/mafintosh/z32) key for a Hyperdrive or Hypercore , or a domain to parse with the [DNSLink](https://www.dnslink.io/) standard.
+`NAME` can either be the 52 character [z32 encoded](https://github.com/mafintosh/z32) key for a Hyperdrive, `localhost` for the `default` drive, or a domain to parse with the [DNSLink](https://www.dnslink.io/) standard.
 
 The mtime metadata is automatically set to the current time when
 uploading. To override this value, pass a `Last-Modified` header with a value
@@ -145,7 +165,7 @@ The `filename` will be the filename within the directory that gets created.
 
 Note that you must use the name `file` for uploaded files.
 
-`NAME` can either be the 52 character [z32 encoded](https://github.com/mafintosh/z32) key for a Hyperdrive or Hypercore , or a domain to parse with the [DNSLink](https://www.dnslink.io/) standard.
+`NAME` can either be the 52 character [z32 encoded](https://github.com/mafintosh/z32) key for a Hyperdrive, `localhost` for the `default` drive, or a domain to parse with the [DNSLink](https://www.dnslink.io/) standard.
 
 ### `fetch('hyper://NAME/', {method: 'DELETE'})`
 
@@ -155,13 +175,13 @@ If this is a writable drive, your data will get fully clearned and trying to wri
 
 If you try to load this drive again data will be loaded from scratch.
 
-`NAME` can either be the 52 character [z32 encoded](https://github.com/mafintosh/z32) key for a Hyperdrive or Hypercore , or a domain to parse with the [DNSLink](https://www.dnslink.io/) standard.
+`NAME` can either be the 52 character [z32 encoded](https://github.com/mafintosh/z32) key for a Hyperdrive, `localhost` for the `default` drive, or a domain to parse with the [DNSLink](https://www.dnslink.io/) standard.
 
 ### `fetch('hyper://NAME/example.txt', {method: 'DELETE'})`
 
 You can delete a file or directory tree in a Hyperdrive by using the `DELETE` method.
 
-`NAME` can either be the 52 character [z32 encoded](https://github.com/mafintosh/z32) key for a Hyperdrive or Hypercore , or a domain to parse with the [DNSLink](https://www.dnslink.io/) standard.
+`NAME` can either be the 52 character [z32 encoded](https://github.com/mafintosh/z32) key for a Hyperdrive, `localhost` for the `default` drive, or a domain to parse with the [DNSLink](https://www.dnslink.io/) standard.
 
 Note that this is only available with the `writable: true` flag.
 

package/dist/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ *
+ * @param {object} options
+ * @param {import('hyper-sdk').SDK} options.sdk
+ * @param {boolean} [options.writable]
+ * @param {boolean} [options.extensionMessages]
+ * @param {number} [options.timeout]
+ * @param {typeof DEFAULT_RENDER_INDEX} [options.renderIndex]
+ * @param {OnLoadHandler} [options.onLoad]
+ * @param {OnDeleteHandler} [options.onDelete]
+ * @returns {Promise<typeof globalThis.fetch>}
+ */
+export default function makeHyperFetch({ sdk, writable, extensionMessages, timeout, renderIndex, onLoad, onDelete }: {
+    sdk: import("hyper-sdk").SDK;
+    writable?: boolean | undefined;
+    extensionMessages?: boolean | undefined;
+    timeout?: number | undefined;
+    renderIndex?: typeof DEFAULT_RENDER_INDEX | undefined;
+    onLoad?: OnLoadHandler | undefined;
+    onDelete?: OnDeleteHandler | undefined;
+}): Promise<typeof globalThis.fetch>;
+export const ERROR_KEY_NOT_CREATED: "Must create key with POST before reading";
+export const ERROR_DRIVE_EMPTY: "Could not find data in drive, make sure your key is correct and that there are peers online to load data from";
+export type RenderIndexHandler = (url: URL, files: string[], fetch: typeof globalThis.fetch) => Promise<string>;
+export type OnLoadHandler = (url: URL, writable: boolean, name?: string) => void;
+export type OnDeleteHandler = (url: URL) => void;
+declare function DEFAULT_RENDER_INDEX(url: URL, files: string[], fetch: typeof globalThis.fetch): Promise<string>;
+export {};

package/dist/test.d.ts

@@ -0,0 +1 @@
+export {};

package/index.js

@@ -1,12 +1,21 @@
 import { posix } from 'path'
 
+// @ts-ignore
 import { Readable, pipelinePromise } from 'streamx'
 import { makeRoutedFetch } from 'make-fetch'
 import mime from 'mime/index.js'
 import parseRange from 'range-parser'
 import { EventIterator } from 'event-iterator'
 
+/** @import Hypercore from 'hypercore' */
+/** @import Hyperdrive from 'hyperdrive' */
+
+/** @typedef {(url: URL, files: string[], fetch: typeof globalThis.fetch) => Promise<string>} RenderIndexHandler */
+/** @typedef {(url: URL, writable: boolean, name?: string) => void}  OnLoadHandler */
+/** @typedef {(url: URL) => void} OnDeleteHandler */
+
 const DEFAULT_TIMEOUT = 5000
+const DEFAULT_DRIVE = 'default'
 
 const SPECIAL_DOMAIN = 'localhost'
 const SPECIAL_FOLDER = '$'
@@ -47,6 +56,7 @@ const INDEX_FILES = [
   'README.org'
 ]
 
+/** @type {RenderIndexHandler} */
 async function DEFAULT_RENDER_INDEX (url, files, fetch) {
   return `
 <!DOCTYPE html>
@@ -65,12 +75,30 @@ mime.define({
   'text/gemini': ['gmi', 'gemini']
 }, true)
 
+function noop () {}
+
+/**
+ *
+ * @param {object} options
+ * @param {import('hyper-sdk').SDK} options.sdk
+ * @param {boolean} [options.writable]
+ * @param {boolean} [options.extensionMessages]
+ * @param {number} [options.timeout]
+ * @param {string} [options.defaultDrive]
+ * @param {typeof DEFAULT_RENDER_INDEX} [options.renderIndex]
+ * @param {OnLoadHandler} [options.onLoad]
+ * @param {OnDeleteHandler} [options.onDelete]
+ * @returns {Promise<typeof globalThis.fetch>}
+ */
 export default async function makeHyperFetch ({
   sdk,
   writable = false,
   extensionMessages = writable,
   timeout = DEFAULT_TIMEOUT,
-  renderIndex = DEFAULT_RENDER_INDEX
+  defaultDrive = DEFAULT_DRIVE,
+  renderIndex = DEFAULT_RENDER_INDEX,
+  onLoad = noop,
+  onDelete = noop
 }) {
   const { fetch, router } = makeRoutedFetch({
     onError
@@ -90,6 +118,10 @@ export default async function makeHyperFetch ({
   if (writable) {
     router.get(`hyper://${SPECIAL_DOMAIN}/`, getKey)
     router.post(`hyper://${SPECIAL_DOMAIN}/`, createKey)
+    router.put(`hyper://${SPECIAL_DOMAIN}/`, putFilesDefault)
+    router.delete('hyper://SPECIAL_DOMAIN/**', deleteFilesDefault)
+    router.get(`hyper://${SPECIAL_DOMAIN}/**`, getFilesDefault)
+    router.head(`hyper://${SPECIAL_DOMAIN}/**`, headFilesDefault)
 
     router.put(`hyper://*/${SPECIAL_FOLDER}/${VERSION_FOLDER_NAME}/**`, putFilesVersioned)
     router.put('hyper://*/**', putFiles)
@@ -103,8 +135,14 @@ export default async function makeHyperFetch ({
   router.get('hyper://*/**', getFiles)
   router.head('hyper://*/**', headFiles)
 
-  async function onError (e, request) {
+  /**
+   *
+   * @param {Error} e
+   * @returns {Promise<import('make-fetch').ResponseLike>}
+   */
+  async function onError (e) {
     return {
+      // @ts-ignore
       status: e.statusCode || 500,
       headers: {
         'Content-Type': 'text/plain; charset=utf-8'
@@ -113,6 +151,12 @@ export default async function makeHyperFetch ({
     }
   }
 
+  /**
+   *
+   * @param {Hypercore} core
+   * @param {string} name
+   * @returns
+   */
   async function getExtension (core, name) {
     const key = core.url + name
     if (extensions.has(key)) {
@@ -125,7 +169,7 @@ export default async function makeHyperFetch ({
     }
 
     const extension = core.registerExtension(name, {
-      encoding: 'utf8',
+      encoding: 'utf-8',
       onmessage: (content, peer) => {
         core.emit(EXTENSION_EVENT, name, content, peer)
       }
@@ -136,6 +180,11 @@ export default async function makeHyperFetch ({
     return extension
   }
 
+  /**
+   * @param {Hypercore} core
+   * @param {string} name
+   * @returns
+   */
   async function getExtensionPeers (core, name) {
     // List peers with this extension
     const allPeers = core.peers
@@ -144,10 +193,18 @@ export default async function makeHyperFetch ({
     })
   }
 
+  /**
+   * @param {Hypercore} core
+   * @returns
+   */
   function listExtensionNames (core) {
     return [...core.extensions.keys()]
   }
 
+  /**
+   * @param {Request} request
+   * @returns
+   */
   async function listExtensions (request) {
     const { hostname } = new URL(request.url)
     const accept = request.headers.get('Accept') || ''
@@ -156,6 +213,12 @@ export default async function makeHyperFetch ({
 
     if (accept.includes('text/event-stream')) {
       const events = new EventIterator(({ push }) => {
+        /**
+         *
+         * @param {string} name
+         * @param {string} content
+         * @param {import('hypercore').Peer} peer
+         */
         function onMessage (name, content, peer) {
           const id = peer.remotePublicKey.toString('hex')
           // TODO: Fancy verification on the `name`?
@@ -164,10 +227,18 @@ export default async function makeHyperFetch ({
 
           push(`id:${id}\nevent:${name}\n${data}\n`)
         }
+
+        /**
+         * @param {import('hypercore').Peer} peer
+         */
         function onPeerOpen (peer) {
           const id = peer.remotePublicKey.toString('hex')
           push(`id:${id}\nevent:${PEER_OPEN}\n\n`)
         }
+
+        /**
+         * @param {import('hypercore').Peer} peer
+         */
         function onPeerRemove (peer) {
           // Whatever, probably an uninitialized peer
           if (!peer.remotePublicKey) return
@@ -201,6 +272,10 @@ export default async function makeHyperFetch ({
     }
   }
 
+  /**
+   * @param {Request} request
+   * @returns
+   */
   async function listenExtension (request) {
     const { hostname, pathname: rawPathname } = new URL(request.url)
     const pathname = decodeURI(ensureLeadingSlash(rawPathname))
@@ -223,6 +298,10 @@ export default async function makeHyperFetch ({
     }
   }
 
+  /**
+   * @param {Request} request
+   * @returns
+   */
   async function broadcastExtension (request) {
     const { hostname, pathname: rawPathname } = new URL(request.url)
     const pathname = decodeURI(ensureLeadingSlash(rawPathname))
@@ -238,6 +317,10 @@ export default async function makeHyperFetch ({
     return { status: 200 }
   }
 
+  /**
+   * @param {Request} request
+   * @returns
+   */
   async function extensionToPeer (request) {
     const { hostname, pathname: rawPathname } = new URL(request.url)
     const pathname = decodeURI(ensureLeadingSlash(rawPathname))
@@ -264,21 +347,24 @@ export default async function makeHyperFetch ({
     return { status: 200 }
   }
 
+  /**
+   * @param {Request} request
+   * @returns
+   */
   async function getKey (request) {
-    const key = new URL(request.url).searchParams.get('key')
-    if (!key) {
-      return { status: 400, body: 'Must specify key parameter to resolve' }
-    }
+    const key = new URL(request.url).searchParams.get('key') || defaultDrive
 
     try {
       const drive = await sdk.getDrive(key)
+      onLoad(new URL('/', drive.url), drive.writable, key)
 
       return { body: drive.url }
     } catch (e) {
-      if (e.message === ERROR_KEY_NOT_CREATED) {
+      const message = /** @type Error */(e).message
+      if (message === ERROR_KEY_NOT_CREATED) {
         return {
           status: 400,
-          body: e.message,
+          body: message,
           headers: {
             [HEADER_CONTENT_TYPE]: MIME_TEXT_PLAIN
           }
@@ -287,39 +373,67 @@ export default async function makeHyperFetch ({
     }
   }
 
+  /**
+   * @param {Request} request
+   * @returns
+   */
   async function createKey (request) {
     // TODO: Allow importing secret keys here
     // Maybe specify a seed to use for generating the blobs?
     // Else we'd need to specify the blobs keys and metadata keys
 
-    const key = new URL(request.url).searchParams.get('key')
-    if (!key) {
-      return { status: 400, body: 'Must specify key parameter to resolve' }
-    }
+    const key = new URL(request.url).searchParams.get('key') || defaultDrive
 
     const drive = await sdk.getDrive(key)
+    onLoad(new URL('/', drive.url), drive.writable, key)
 
     return { body: drive.url }
   }
 
+  /**
+   * @param {Request} request
+   */
+  async function putFilesDefault (request) {
+    const finalURL = await resolveInDefault(request.url)
+
+    return putTo(finalURL, request)
+  }
+
+  /**
+   * @param {Request} request
+   * @returns
+   */
   async function putFiles (request) {
-    const { hostname, pathname: rawPathname } = new URL(request.url)
+    return putTo(request.url, request)
+  }
+
+  /**
+   * @param {string} url
+   * @param {Request} request
+   * @returns
+   */
+  async function putTo (url, request) {
+    const { hostname, pathname: rawPathname } = new URL(url)
     const pathname = decodeURI(ensureLeadingSlash(rawPathname))
     const contentType = request.headers.get('Content-Type') || ''
-    const mtime = Date.parse(request.headers.get('Last-Modified')) || Date.now()
+    const lastModified = request.headers.get('Last-Modified')
+    const mtime = lastModified ? Date.parse(lastModified) : Date.now()
     const isFormData = contentType.includes('multipart/form-data')
 
     const drive = await sdk.getDrive(`hyper://${hostname}/`)
 
-    if (!drive.db.feed.writable) {
+    if (!drive.writable) {
       return { status: 403, body: `Cannot PUT file to read-only drive: ${drive.url}`, headers: { Location: request.url } }
     }
 
+    onLoad(new URL('/', url), drive.writable)
+
     if (isFormData) {
       // It's a form! Get the files out and process them
       const formData = await request.formData()
       for (const [name, data] of formData) {
         if (name !== 'file') continue
+        if (typeof data === 'string') continue
         const filePath = posix.join(pathname, data.name)
         await pipelinePromise(
           Readable.from(data.stream()),
@@ -332,7 +446,7 @@ export default async function makeHyperFetch ({
       }
     } else {
       if (pathname.endsWith('/')) {
-        return { status: 405, body: 'Cannot PUT file with trailing slash', headers: { Location: request.url } }
+        return { status: 405, body: 'Cannot PUT file with trailing slash', headers: { Location: url } }
       } else {
         await pipelinePromise(
           Readable.from(request.body),
@@ -357,6 +471,10 @@ export default async function makeHyperFetch ({
     return { status: 201, headers }
   }
 
+  /**
+   * @param {Request} request
+   * @returns
+   */
   function putFilesVersioned (request) {
     return {
       status: 405,
@@ -365,25 +483,54 @@ export default async function makeHyperFetch ({
     }
   }
 
+  /**
+   * @param {Request} request
+   * @returns
+   */
   async function deleteDrive (request) {
     const { hostname } = new URL(request.url)
     const drive = await sdk.getDrive(`hyper://${hostname}/`)
+    onDelete(new URL('/', request.url))
 
     await drive.purge()
 
     return { status: 200 }
   }
 
+  /**
+   * @param {Request} request
+   * @returns
+   */
+  async function deleteFilesDefault (request) {
+    const finalURL = await resolveInDefault(request.url)
+
+    return deleteFilesTo(finalURL, request)
+  }
+
+  /**
+   * @param {Request} request
+   * @returns
+   */
   async function deleteFiles (request) {
-    const { hostname, pathname: rawPathname } = new URL(request.url)
+    return deleteFilesTo(request.url, request)
+  }
+
+  /**
+   * @param {string} url
+   * @param {Request} request
+   * @returns
+   */
+  async function deleteFilesTo (url, request) {
+    const { hostname, pathname: rawPathname } = new URL(url)
     const pathname = decodeURI(ensureLeadingSlash(rawPathname))
 
     const drive = await sdk.getDrive(`hyper://${hostname}/`)
-
-    if (!drive.db.feed.writable) {
-      return { status: 403, body: `Cannot DELETE file in read-only drive: ${drive.url}`, headers: { Location: request.url } }
+    if (!drive.writable) {
+      return { status: 403, body: `Cannot DELETE file in read-only drive: ${drive.url}`, headers: { Location: url } }
     }
 
+    onLoad(new URL('/', url), drive.writable)
+
     if (pathname.endsWith('/')) {
       let didDelete = false
       for await (const entry of drive.list(pathname)) {
@@ -413,10 +560,18 @@ export default async function makeHyperFetch ({
     return { status: 200, headers }
   }
 
+  /**
+   * @param {Request} request
+   * @returns
+   */
   function deleteFilesVersioned (request) {
     return { status: 405, body: 'Cannot DELETE old version', headers: { Location: request.url } }
   }
 
+  /**
+   * @param {Request} request
+   * @returns
+   */
   async function headFilesVersioned (request) {
     const url = new URL(request.url)
     const { hostname, pathname: rawPathname, searchParams } = url
@@ -427,7 +582,7 @@ export default async function makeHyperFetch ({
     const noResolve = searchParams.has('noResolve')
 
     const parts = pathname.split('/')
-    const version = parts[3]
+    const version = parseInt(parts[3], 10)
     const realPath = ensureLeadingSlash(parts.slice(4).join('/'))
 
     const drive = await sdk.getDrive(`hyper://${hostname}/`)
@@ -444,8 +599,31 @@ export default async function makeHyperFetch ({
     return serveHead(snapshot, realPath, { accept, isRanged, noResolve })
   }
 
+  /**
+   * @param {Request} request
+   * @returns
+   */
+  async function headFilesDefault (request) {
+    const finalURL = await resolveInDefault(request.url)
+
+    return headFilesFrom(finalURL, request)
+  }
+
+  /**
+   * @param {Request} request
+   * @returns
+   */
   async function headFiles (request) {
-    const url = new URL(request.url)
+    return headFilesFrom(request.url, request)
+  }
+
+  /**
+   * @param {string} _url
+   * @param {Request} request
+   * @returns
+   */
+  async function headFilesFrom (_url, request) {
+    const url = new URL(_url)
     const { hostname, pathname: rawPathname, searchParams } = url
     const pathname = decodeURI(ensureLeadingSlash(rawPathname))
 
@@ -465,19 +643,30 @@ export default async function makeHyperFetch ({
     return serveHead(drive, pathname, { accept, isRanged, noResolve })
   }
 
+  /**
+   *
+   * @param {Hyperdrive} drive
+   * @param {*} pathname
+   * @param {object} options
+   * @param {string} options.accept
+   * @param {string} options.isRanged
+   * @param {boolean} options.noResolve
+   * @returns
+   */
   async function serveHead (drive, pathname, { accept, isRanged, noResolve }) {
     const isDirectory = pathname.endsWith('/')
     const fullURL = new URL(pathname, drive.url).href
 
-    const isWritable = writable && drive.db.feed.writable
+    const isWritable = writable && drive.writable
 
     const Allow = isWritable ? BASIC_METHODS.concat(WRITABLE_METHODS) : BASIC_METHODS
 
+    /** @type {{[key: string]: string}} */
     const resHeaders = {
       ETag: `${drive.version}`,
       'Accept-Ranges': 'bytes',
       Link: `<${fullURL}>; rel="canonical"`,
-      Allow
+      Allow: Allow.toString()
     }
 
     if (isDirectory) {
@@ -549,8 +738,9 @@ export default async function makeHyperFetch ({
     const size = entry.value.blob.byteLength
     if (isRanged) {
       const ranges = parseRange(size, isRanged)
+      const isRangeValid = ranges !== -1 && ranges !== -2 && ranges
 
-      if (ranges && ranges.length && ranges.type === 'bytes') {
+      if (isRangeValid && ranges.length && ranges.type === 'bytes') {
         const [{ start, end }] = ranges
         const length = (end - start + 1)
 
@@ -571,6 +761,10 @@ export default async function makeHyperFetch ({
     }
   }
 
+  /**
+   * @param {Request} request
+   * @returns
+   */
   async function getFilesVersioned (request) {
     const url = new URL(request.url)
     const { hostname, pathname: rawPathname, searchParams } = url
@@ -581,19 +775,51 @@ export default async function makeHyperFetch ({
     const noResolve = searchParams.has('noResolve')
 
     const parts = pathname.split('/')
-    const version = parts[3]
+    const version = parseInt(parts[3], 10)
     const realPath = ensureLeadingSlash(parts.slice(4).join('/'))
 
     const drive = await sdk.getDrive(`hyper://${hostname}/`)
 
+    if (!drive.writable && !drive.core.length) {
+      return {
+        status: 404,
+        body: 'Peers Not Found'
+      }
+    }
+
+    onLoad(new URL('/', request.url), drive.writable)
+
     const snapshot = await drive.checkout(version)
 
     return serveGet(snapshot, realPath, { accept, isRanged, noResolve })
   }
 
-  // TODO: Redirect on directories without trailing slash
+  /**
+  * @param {Request} request
+  * @returns
+  */
+  async function getFilesDefault (request) {
+    const finalURL = await resolveInDefault(request.url)
+
+    return getFilesFrom(finalURL, request)
+  }
+
+  /**
+   * @param {Request} request
+   * @returns
+   */
   async function getFiles (request) {
-    const url = new URL(request.url)
+    return getFilesFrom(request.url, request)
+  }
+
+  /**
+   * @param {string} _url
+   * @param {Request} request
+   * @returns
+   */
+  async function getFilesFrom (_url, request) {
+    // TODO: Redirect on directories without trailing slash
+    const url = new URL(_url)
     const { hostname, pathname: rawPathname, searchParams } = url
     const pathname = decodeURI(ensureLeadingSlash(rawPathname))
 
@@ -610,9 +836,20 @@ export default async function makeHyperFetch ({
       }
     }
 
+    onLoad(new URL('/', url), drive.writable)
+
     return serveGet(drive, pathname, { accept, isRanged, noResolve })
   }
 
+  /**
+   * @param {Hyperdrive} drive
+   * @param {string} pathname
+   * @param {object} options
+   * @param {string} options.accept
+   * @param {string} options.isRanged
+   * @param {boolean} options.noResolve
+   * @returns
+   */
   async function serveGet (drive, pathname, { accept, isRanged, noResolve }) {
     const isDirectory = pathname.endsWith('/')
     const fullURL = new URL(pathname, drive.url).href
@@ -675,9 +912,30 @@ export default async function makeHyperFetch ({
     return serveFile(drive, path, isRanged)
   }
 
+  /**
+   * Resolve a URL with a pathname to be within the default drive
+   * @param {string} url
+   * @returns {Promise<string>}
+   */
+  async function resolveInDefault (url) {
+    const { pathname } = new URL(url)
+
+    const drive = await sdk.getDrive(defaultDrive)
+    const finalURL = new URL(pathname, drive.url).href
+
+    return finalURL
+  }
+
   return fetch
 }
 
+/**
+ *
+ * @param {Hyperdrive} drive
+ * @param {string} pathname
+ * @param {string} [isRanged]
+ * @returns
+ */
 async function serveFile (drive, pathname, isRanged) {
   const contentType = getMimeType(pathname)
 
@@ -685,6 +943,7 @@ async function serveFile (drive, pathname, isRanged) {
 
   const entry = await drive.entry(pathname)
 
+  /** @type {{[key: string]: string}} */
   const resHeaders = {
     ETag: `${entry.seq + 1}`,
     [HEADER_CONTENT_TYPE]: contentType,
@@ -700,8 +959,9 @@ async function serveFile (drive, pathname, isRanged) {
   const size = entry.value.blob.byteLength
   if (isRanged) {
     const ranges = parseRange(size, isRanged)
+    const isRangeValid = ranges !== -1 && ranges !== -2 && ranges
 
-    if (ranges && ranges.length && ranges.type === 'bytes') {
+    if (isRangeValid && ranges.length && ranges.type === 'bytes') {
       const [{ start, end }] = ranges
       const length = (end - start + 1)
 
@@ -729,6 +989,10 @@ async function serveFile (drive, pathname, isRanged) {
   }
 }
 
+/**
+ * @param {string} pathname
+ * @returns {string[]}
+ */
 function makeToTry (pathname) {
   return [
     pathname,
@@ -737,6 +1001,12 @@ function makeToTry (pathname) {
   ]
 }
 
+/**
+ * @param {Hyperdrive} drive
+ * @param {string} pathname
+ * @param {boolean} noResolve
+ * @returns
+ */
 async function resolvePath (drive, pathname, noResolve) {
   if (noResolve) {
     const entry = await drive.entry(pathname)
@@ -754,6 +1024,12 @@ async function resolvePath (drive, pathname, noResolve) {
   return { entry: null, path: null }
 }
 
+/**
+ *
+ * @param {Hyperdrive} drive
+ * @param {string} [pathname]
+ * @returns
+ */
 async function listEntries (drive, pathname = '/') {
   const entries = []
   for await (const path of drive.readdir(pathname)) {
@@ -768,9 +1044,15 @@ async function listEntries (drive, pathname = '/') {
   return entries
 }
 
+/**
+ *
+ * @param {import('hypercore').Peer[]} peers
+ * @returns
+ */
 function formatPeers (peers) {
   return peers.map((peer) => {
     const remotePublicKey = peer.remotePublicKey.toString('hex')
+    // @ts-ignore
     const remoteHost = peer.stream?.rawStream?.remoteHost
     return {
       remotePublicKey,
@@ -779,12 +1061,22 @@ function formatPeers (peers) {
   })
 }
 
+/**
+ *
+ * @param {string} path
+ * @returns {string}
+ */
 function getMimeType (path) {
   let mimeType = mime.getType(path) || 'text/plain; charset=utf-8'
   if (mimeType.startsWith('text/')) mimeType = `${mimeType}; charset=utf-8`
   return mimeType
 }
 
+/**
+ *
+ * @param {string} path
+ * @returns {string}
+ */
 function ensureLeadingSlash (path) {
   return path.startsWith('/') ? path : '/' + path
 }

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "hypercore-fetch",
-  "version": "10.0.0",
+  "version": "10.2.0",
   "description": "Implementation of Fetch that uses the Dat SDK for loading p2p content",
   "type": "module",
   "main": "index.js",
+  "types": "./dist/index.d.ts",
   "scripts": {
     "test": "node test",
-    "lint": "standard --fix"
+    "lint": "standard --fix && tsc --noEmit",
+    "build": "tsc",
+    "preversion": "npm run lint && npm run test"
   },
   "repository": {
     "type": "git",
@@ -14,6 +17,7 @@
   },
   "keywords": [
     "dat",
+    "hypercore",
     "fetch"
   ],
   "author": "RangerMauve",
@@ -24,15 +28,21 @@
   "homepage": "https://github.com/RangerMauve/hypercore-fetch#readme",
   "dependencies": {
     "event-iterator": "^2.0.0",
-    "make-fetch": "^3.1.1",
+    "make-fetch": "^3.2.3",
     "mime": "^3.0.0",
     "range-parser": "^1.2.1",
     "streamx": "^2.13.0"
   },
   "devDependencies": {
-    "@rangermauve/fetch-event-source": "^1.0.3",
-    "hyper-sdk": "^6.0.0",
+    "@rangermauve/fetch-event-source": "^2.0.1",
+    "@tsconfig/node20": "^20.1.8",
+    "@types/mime": "^3.0.4",
+    "@types/range-parser": "^1.2.7",
+    "@types/streamx": "^2.9.5",
+    "@types/tape": "^5.8.1",
+    "hyper-sdk": "^6.2.1",
     "standard": "^17.0.0",
-    "tape": "^5.2.2"
+    "tape": "^5.2.2",
+    "typescript": "^5.9.3"
   }
 }

package/test.js

@@ -9,15 +9,28 @@ import { rm } from 'fs/promises'
 
 import makeHyperFetch from './index.js'
 
+/** @import {OnLoadHandler, OnDeleteHandler} from './index.js' */
+
 const SAMPLE_CONTENT = 'Hello World'
 const DNS_DOMAIN = 'blog.mauve.moe'
 let count = 0
+
+/** @type {OnLoadHandler | null} */
+let onLoad = null
+/** @type {OnDeleteHandler | null} */
+let onDelete = null
+
 function next () {
   return count++
 }
 
-async function nextURL (t) {
-  const createResponse = await fetch(`hyper://localhost/?key=example${next()}`, {
+/**
+ * @param {import('tape').Test} t
+ * @param {string} [name]
+ * @returns {Promise<string>}
+ */
+async function nextURL (t, name = `example${next()}`) {
+  const createResponse = await fetch(`hyper://localhost/?key=${name}`, {
     method: 'post'
   })
   await checkResponse(createResponse, t, 'Created new drive')
@@ -34,7 +47,9 @@ const sdk2 = await SDK.create({ storage: join(tmp, 'sdk2') })
 
 const fetch = await makeHyperFetch({
   sdk: sdk1,
-  writable: true
+  writable: true,
+  onLoad: (...args) => onLoad && onLoad(...args),
+  onDelete: (...args) => onDelete && onDelete(...args)
 })
 
 const fetch2 = await makeHyperFetch({
@@ -82,7 +97,7 @@ test('Quick check', async (t) => {
 
   const content = await uploadedContentResponse.text()
   const contentType = uploadedContentResponse.headers.get('Content-Type')
-  const contentLink = uploadedContentResponse.headers.get('Link')
+  const contentLink = uploadedContentResponse.headers.get('Link') ?? ''
 
   t.match(contentLink, /^<hyper:\/\/[0-9a-z]{52}\/example%20.txt>; rel="canonical"$/, 'Link header includes both public key and path.')
   t.equal(contentType, 'text/plain; charset=utf-8', 'Content got expected mime type')
@@ -127,7 +142,7 @@ test('HEAD request', async (t) => {
   const headersContentLength = headResponse.headers.get('Content-Length')
   const headersAcceptRanges = headResponse.headers.get('Accept-Ranges')
   const headersLastModified = headResponse.headers.get('Last-Modified')
-  const headersLink = headResponse.headers.get('Link')
+  const headersLink = headResponse.headers.get('Link') ?? ''
 
   t.equal(headResponse.status, 204, 'Response had expected status')
   // Version at which the file was added
@@ -144,7 +159,7 @@ test('PUT file', async (t) => {
 
   const uploadLocation = new URL('./example.txt', created)
 
-  const fakeDate = new Date(Date.parse(0)).toUTCString()
+  const fakeDate = new Date().toUTCString()
   const uploadResponse = await fetch(uploadLocation, {
     method: 'put',
     body: SAMPLE_CONTENT,
@@ -464,12 +479,12 @@ test('EventSource extension messages', async (t) => {
   t.deepEqual(extensionList, ['example'], 'Got expected list of extensions')
 
   const peerResponse1 = await fetch(extensionURL)
-  const peerList1 = await peerResponse1.json()
+  const peerList1 = /** @type {object[]} */ (await peerResponse1.json())
 
   t.equal(peerList1.length, 1, 'Got one peer for extension message on peer1')
 
   const peerResponse2 = await fetch2(extensionURL)
-  const peerList2 = await peerResponse2.json()
+  const peerList2 = /** @type {object[]} */ (await peerResponse2.json())
 
   t.equal(peerList2.length, 1, 'Got one peer for extension message on peer2')
 
@@ -502,11 +517,13 @@ test('EventSource extension messages', async (t) => {
 test('Resolve DNS', async (t) => {
   const loadResponse = await fetch(`hyper://${DNS_DOMAIN}/?noResolve`)
 
-  const entries = await loadResponse.json()
+  const entries = /** @type {object[]} */ (await loadResponse.json())
 
   t.ok(entries.length, 'Loaded contents with some files present')
 
-  const rawLink = loadResponse.headers.get('Link').match(/<(.+)>/)[1]
+  const linkHeader = loadResponse.headers.get('Link') || ''
+  // @ts-ignore
+  const rawLink = linkHeader.match(/<(.+)>/)[1]
   const loadRawURLResponse = await fetch(rawLink + '?noResolve')
 
   const rawLinkEntries = await loadRawURLResponse.json()
@@ -652,10 +669,59 @@ test('Check hyperdrive writability', async (t) => {
   t.equal(writableHeadersAllow, 'HEAD,GET,PUT,DELETE', 'Expected writable Allows header')
 })
 
+test('onLoad and onDelete handlers', async (t) => {
+  /** @type {Parameters<OnLoadHandler> | Parameters<OnDeleteHandler> | null} */
+  let args = null
+
+  onLoad = (..._args) => {
+    args = _args
+  }
+  onDelete = (..._args) => {
+    args = _args
+  }
+
+  const created = await nextURL(t, 'example')
+
+  if (args === null) return t.fail('onLoad did not get called')
+  // @ts-ignore For some reason TS can't tell args gets set
+  t.equal(args[0].toString(), created, 'onLoad got created URL')
+  t.equal(args[1], true, 'onLoad knows created URL is writable')
+  t.equal(args[2], 'example', 'onLoad knows key for created URL')
+
+  args = null
+
+  const toFetch = `hyper://${DNS_DOMAIN}/`
+  const response = await fetch(toFetch + 'index.html')
+  await response.text()
+
+  if (args === null) return t.fail('onLoad did not get called')
+  // @ts-ignore For some reason TS can't tell args gets set
+  t.equal(args[0].toString(), toFetch, 'onLoad got loaded URL')
+  t.equal(args[1], false, 'onLoad knows loaded URL is not writable')
+  t.equal(args[2], undefined, 'onLoad lacks key for loaded domain')
+
+  args = null
+
+  await fetch(toFetch, {
+    method: 'DELETE'
+  })
+
+  if (args === null) return t.fail('onDelete did not get called')
+  // @ts-ignore For some reason TS can't tell args gets set
+  t.equal(args[0].toString(), toFetch, 'onDelete got URL of deleted drive')
+})
+
+/**
+ *
+ * @param {Response} response
+ * @param {import('tape').Test} t
+ * @param {string} [successMessage]
+ * @returns
+ */
 async function checkResponse (response, t, successMessage = 'Response OK') {
   if (!response.ok) {
     const message = await response.text()
-    t.fail(new Error(`HTTP Error ${response.status}:\n${message}`))
+    t.fail(`HTTP Error ${response.status}:\n${message}`)
     return false
   } else {
     t.pass(successMessage)

package/tsconfig.json

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