npm - hypercore-fetch - Versions diffs - 10.0.0 → 10.1.0 - Mend

hypercore-fetch 10.0.0 → 10.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

package/README.md CHANGED Viewed

@@ -16,7 +16,7 @@ const fetch = await makeFetch({
   writable: true
 })
-const someURL = `hyper://TODO_REAL_URL_HERE_PLEASE`
+const someURL = `hyper://blog.mauve.moe/`
 const response = await fetch(someURL)
@@ -27,7 +27,7 @@ console.log(data)
 ## 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 +40,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

package/dist/index.d.ts ADDED Viewed

@@ -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 ADDED Viewed

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

package/index.js CHANGED Viewed

@@ -1,11 +1,19 @@
 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 SPECIAL_DOMAIN = 'localhost'
@@ -47,6 +55,7 @@ const INDEX_FILES = [
   'README.org'
 ]
+/** @type {RenderIndexHandler} */
 async function DEFAULT_RENDER_INDEX (url, files, fetch) {
   return `
 <!DOCTYPE html>
@@ -65,12 +74,28 @@ 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 {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
+  renderIndex = DEFAULT_RENDER_INDEX,
+  onLoad = noop,
+  onDelete = noop
 }) {
   const { fetch, router } = makeRoutedFetch({
     onError
@@ -103,8 +128,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 +144,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 +162,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 +173,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 +186,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 +206,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 +220,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 +265,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 +291,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 +310,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,6 +340,10 @@ 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) {
@@ -272,13 +352,15 @@ export default async function makeHyperFetch ({
     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,6 +369,10 @@ 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?
@@ -298,28 +384,37 @@ export default async function makeHyperFetch ({
     }
     const drive = await sdk.getDrive(key)
+    onLoad(new URL('/', drive.url), drive.writable, key)
     return { body: drive.url }
   }
+  /**
+   * @param {Request} request
+   * @returns
+   */
   async function putFiles (request) {
     const { hostname, pathname: rawPathname } = new URL(request.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('/', request.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()),
@@ -357,6 +452,10 @@ export default async function makeHyperFetch ({
     return { status: 201, headers }
   }
+  /**
+   * @param {Request} request
+   * @returns
+   */
   function putFilesVersioned (request) {
     return {
       status: 405,
@@ -365,25 +464,35 @@ 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 deleteFiles (request) {
     const { hostname, pathname: rawPathname } = new URL(request.url)
     const pathname = decodeURI(ensureLeadingSlash(rawPathname))
     const drive = await sdk.getDrive(`hyper://${hostname}/`)
-    if (!drive.db.feed.writable) {
+    if (!drive.writable) {
       return { status: 403, body: `Cannot DELETE file in read-only drive: ${drive.url}`, headers: { Location: request.url } }
     }
+    onLoad(new URL('/', request.url), drive.writable)
     if (pathname.endsWith('/')) {
       let didDelete = false
       for await (const entry of drive.list(pathname)) {
@@ -413,10 +522,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 +544,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,6 +561,10 @@ export default async function makeHyperFetch ({
     return serveHead(snapshot, realPath, { accept, isRanged, noResolve })
   }
+  /**
+   * @param {Request} request
+   * @returns
+   */
   async function headFiles (request) {
     const url = new URL(request.url)
     const { hostname, pathname: rawPathname, searchParams } = url
@@ -465,19 +586,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 +681,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 +704,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,18 +718,31 @@ 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 getFiles (request) {
+    // TODO: Redirect on directories without trailing slash
     const url = new URL(request.url)
     const { hostname, pathname: rawPathname, searchParams } = url
     const pathname = decodeURI(ensureLeadingSlash(rawPathname))
@@ -610,9 +760,20 @@ export default async function makeHyperFetch ({
       }
     }
+    onLoad(new URL('/', request.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
@@ -678,6 +839,13 @@ export default async function makeHyperFetch ({
   return fetch
 }
+/**
+ *
+ * @param {Hyperdrive} drive
+ * @param {string} pathname
+ * @param {string} [isRanged]
+ * @returns
+ */
 async function serveFile (drive, pathname, isRanged) {
   const contentType = getMimeType(pathname)
@@ -685,6 +853,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 +869,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 +899,10 @@ async function serveFile (drive, pathname, isRanged) {
   }
 }
+/**
+ * @param {string} pathname
+ * @returns {string[]}
+ */
 function makeToTry (pathname) {
   return [
     pathname,
@@ -737,6 +911,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 +934,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 +954,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 +971,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 CHANGED Viewed

@@ -1,12 +1,15 @@
 {
   "name": "hypercore-fetch",
-  "version": "10.0.0",
+  "version": "10.1.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 CHANGED Viewed

@@ -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.only('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 ADDED Viewed

@@ -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"
+    ]
+}