feat: add name property to errors

Adds a `.name` property to all errors that can be used in a more
ideomatic way than `.code`.

packages/ipfs-unixfs-exporter/package.json

@@ -54,7 +54,6 @@
     "@ipld/dag-json": "^10.2.0",
     "@ipld/dag-pb": "^4.1.0",
     "@multiformats/murmur3": "^2.1.8",
-    "err-code": "^3.0.1",
     "hamt-sharding": "^3.0.6",
     "interface-blockstore": "^5.2.10",
     "ipfs-unixfs": "^11.0.0",

packages/ipfs-unixfs-exporter/src/errors.ts

@@ -0,0 +1,87 @@
+export class BadPathError extends Error {
+  static name = 'BadPathError'
+  static code = 'ERR_BAD_PATH'
+  name = BadPathError.name
+  code = BadPathError.code
+
+  constructor (message = 'Bad path') {
+    super(message)
+  }
+}
+
+export class NotFoundError extends Error {
+  static name = 'NotFoundError'
+  static code = 'ERR_NOT_FOUND'
+  name = NotFoundError.name
+  code = NotFoundError.code
+
+  constructor (message = 'Not found') {
+    super(message)
+  }
+}
+
+export class NoResolverError extends Error {
+  static name = 'NoResolverError'
+  static code = 'ERR_NO_RESOLVER'
+  name = NoResolverError.name
+  code = NoResolverError.code
+
+  constructor (message = 'No resolver') {
+    super(message)
+  }
+}
+
+export class NotUnixFSError extends Error {
+  static name = 'NotUnixFSError'
+  static code = 'ERR_NOT_UNIXFS'
+  name = NotUnixFSError.name
+  code = NotUnixFSError.code
+
+  constructor (message = 'Not UnixFS') {
+    super(message)
+  }
+}
+
+export class OverReadError extends Error {
+  static name = 'OverReadError'
+  static code = 'ERR_OVER_READ'
+  name = OverReadError.name
+  code = OverReadError.code
+
+  constructor (message = 'Over read') {
+    super(message)
+  }
+}
+
+export class UnderReadError extends Error {
+  static name = 'UnderReadError'
+  static code = 'ERR_UNDER_READ'
+  name = UnderReadError.name
+  code = UnderReadError.code
+
+  constructor (message = 'Under read') {
+    super(message)
+  }
+}
+
+export class NoPropError extends Error {
+  static name = 'NoPropError'
+  static code = 'ERR_NO_PROP'
+  name = NoPropError.name
+  code = NoPropError.code
+
+  constructor (message = 'No Property found') {
+    super(message)
+  }
+}
+
+export class InvalidParametersError extends Error {
+  static name = 'InvalidParametersError'
+  static code = 'ERR_INVALID_PARAMS'
+  name = InvalidParametersError.name
+  code = InvalidParametersError.code
+
+  constructor (message = 'Invalid parameters') {
+    super(message)
+  }
+}

packages/ipfs-unixfs-exporter/src/index.ts

@@ -45,16 +45,18 @@
  * ```
  */
 
-import errCode from 'err-code'
 import last from 'it-last'
 import { CID } from 'multiformats/cid'
+import { BadPathError, NotFoundError } from './errors.js'
 import resolve from './resolvers/index.js'
 import type { PBNode } from '@ipld/dag-pb'
 import type { Bucket } from 'hamt-sharding'
 import type { Blockstore } from 'interface-blockstore'
 import type { UnixFS } from 'ipfs-unixfs'
 import type { ProgressOptions, ProgressEvent } from 'progress-events'
 
+export * from './errors.js'
+
 export interface ExportProgress {
   /**
    * How many bytes of the file have been read
@@ -361,7 +363,7 @@ const cidAndRest = (path: string | Uint8Array | CID): { cid: CID, toResolve: str
     }
   }
 
-  throw errCode(new Error(`Unknown path type ${path}`), 'ERR_BAD_PATH')
+  throw new BadPathError(`Unknown path type ${path}`)
 }
 
 /**
@@ -394,7 +396,7 @@ export async function * walkPath (path: string | CID, blockstore: ReadableStorag
     const result = await resolve(cid, name, entryPath, toResolve, startingDepth, blockstore, options)
 
     if (result.entry == null && result.next == null) {
-      throw errCode(new Error(`Could not resolve ${path}`), 'ERR_NOT_FOUND')
+      throw new NotFoundError(`Could not resolve ${path}`)
     }
 
     if (result.entry != null) {
@@ -441,7 +443,7 @@ export async function exporter (path: string | CID, blockstore: ReadableStorage,
   const result = await last(walkPath(path, blockstore, options))
 
   if (result == null) {
-    throw errCode(new Error(`Could not resolve ${path}`), 'ERR_NOT_FOUND')
+    throw new NotFoundError(`Could not resolve ${path}`)
   }
 
   return result

packages/ipfs-unixfs-exporter/src/resolvers/identity.ts

@@ -1,6 +1,6 @@
-import errCode from 'err-code'
 import * as mh from 'multiformats/hashes/digest'
 import { CustomProgressEvent } from 'progress-events'
+import { NotFoundError } from '../errors.js'
 import extractDataFromBlock from '../utils/extract-data-from-block.js'
 import validateOffsetAndLength from '../utils/validate-offset-and-length.js'
 import type { ExporterOptions, Resolver, ExportProgress } from '../index.js'
@@ -28,7 +28,7 @@ const rawContent = (node: Uint8Array): ((options?: ExporterOptions) => AsyncGene
 
 const resolve: Resolver = async (cid, name, path, toResolve, resolve, depth, blockstore, options) => {
   if (toResolve.length > 0) {
-    throw errCode(new Error(`No link named ${path} found in raw node ${cid}`), 'ERR_NOT_FOUND')
+    throw new NotFoundError(`No link named ${path} found in raw node ${cid}`)
   }
   const buf = mh.decode(cid.multihash.bytes)
 

packages/ipfs-unixfs-exporter/src/resolvers/index.ts

@@ -1,10 +1,10 @@
 import * as dagCbor from '@ipld/dag-cbor'
 import * as dagJson from '@ipld/dag-json'
 import * as dagPb from '@ipld/dag-pb'
-import errCode from 'err-code'
 import * as json from 'multiformats/codecs/json'
 import * as raw from 'multiformats/codecs/raw'
 import { identity } from 'multiformats/hashes/identity'
+import { NoResolverError } from '../errors.js'
 import dagCborResolver from './dag-cbor.js'
 import dagJsonResolver from './dag-json.js'
 import identifyResolver from './identity.js'
@@ -26,7 +26,7 @@ const resolve: Resolve = async (cid, name, path, toResolve, depth, blockstore, o
   const resolver = resolvers[cid.code]
 
   if (resolver == null) {
-    throw errCode(new Error(`No resolver for code ${cid.code}`), 'ERR_NO_RESOLVER')
+    throw new NoResolverError(`No resolver for code ${cid.code}`)
   }
 
   return resolver(cid, name, path, toResolve, resolve, depth, blockstore, options)

packages/ipfs-unixfs-exporter/src/resolvers/raw.ts

@@ -1,5 +1,5 @@
-import errCode from 'err-code'
 import { CustomProgressEvent } from 'progress-events'
+import { NotFoundError } from '../errors.js'
 import extractDataFromBlock from '../utils/extract-data-from-block.js'
 import validateOffsetAndLength from '../utils/validate-offset-and-length.js'
 import type { ExporterOptions, Resolver, ExportProgress } from '../index.js'
@@ -27,7 +27,7 @@ const rawContent = (node: Uint8Array): ((options?: ExporterOptions) => AsyncGene
 
 const resolve: Resolver = async (cid, name, path, toResolve, resolve, depth, blockstore, options) => {
   if (toResolve.length > 0) {
-    throw errCode(new Error(`No link named ${path} found in raw node ${cid}`), 'ERR_NOT_FOUND')
+    throw new NotFoundError(`No link named ${path} found in raw node ${cid}`)
   }
 
   const block = await blockstore.get(cid, options)

packages/ipfs-unixfs-exporter/src/resolvers/unixfs-v1/content/file.ts

@@ -1,5 +1,4 @@
 import * as dagPb from '@ipld/dag-pb'
-import errCode from 'err-code'
 import { UnixFS } from 'ipfs-unixfs'
 import map from 'it-map'
 import parallel from 'it-parallel'
@@ -8,6 +7,7 @@ import { type Pushable, pushable } from 'it-pushable'
 import * as raw from 'multiformats/codecs/raw'
 import PQueue from 'p-queue'
 import { CustomProgressEvent } from 'progress-events'
+import { NotUnixFSError, OverReadError, UnderReadError } from '../../../errors.js'
 import extractDataFromBlock from '../../../utils/extract-data-from-block.js'
 import validateOffsetAndLength from '../../../utils/validate-offset-and-length.js'
 import type { ExporterOptions, UnixfsV1FileContent, UnixfsV1Resolver, ReadableStorage, ExportProgress, ExportWalk } from '../../../index.js'
@@ -23,15 +23,15 @@ async function walkDAG (blockstore: ReadableStorage, node: dagPb.PBNode | Uint8A
   }
 
   if (node.Data == null) {
-    throw errCode(new Error('no data in PBNode'), 'ERR_NOT_UNIXFS')
+    throw new NotUnixFSError('no data in PBNode')
   }
 
   let file: UnixFS
 
   try {
     file = UnixFS.unmarshal(node.Data)
   } catch (err: any) {
-    throw errCode(err, 'ERR_NOT_UNIXFS')
+    throw new NotUnixFSError(err.message)
   }
 
   // might be a unixfs `raw` node or have data on intermediate nodes
@@ -47,7 +47,7 @@ async function walkDAG (blockstore: ReadableStorage, node: dagPb.PBNode | Uint8A
   const childOps: Array<{ link: dagPb.PBLink, blockStart: bigint }> = []
 
   if (node.Links.length !== file.blockSizes.length) {
-    throw errCode(new Error('Inconsistent block sizes and dag links'), 'ERR_NOT_UNIXFS')
+    throw new NotUnixFSError('Inconsistent block sizes and dag links')
   }
 
   for (let i = 0; i < node.Links.length; i++) {
@@ -98,7 +98,7 @@ async function walkDAG (blockstore: ReadableStorage, node: dagPb.PBNode | Uint8A
             child = block
             break
           default:
-            queue.end(errCode(new Error(`Unsupported codec: ${link.Hash.code}`), 'ERR_NOT_UNIXFS'))
+            queue.end(new NotUnixFSError(`Unsupported codec: ${link.Hash.code}`))
             return
         }
 
@@ -171,7 +171,7 @@ const fileContent: UnixfsV1Resolver = (cid, node, unixfs, path, resolve, depth,
 
       if (read > wanted) {
         queue.end()
-        throw errCode(new Error('Read too many bytes - the file size reported by the UnixFS data in the root node may be incorrect'), 'ERR_OVER_READ')
+        throw new OverReadError('Read too many bytes - the file size reported by the UnixFS data in the root node may be incorrect')
       }
 
       if (read === wanted) {
@@ -188,7 +188,7 @@ const fileContent: UnixfsV1Resolver = (cid, node, unixfs, path, resolve, depth,
     }
 
     if (read < wanted) {
-      throw errCode(new Error('Traversed entire DAG but did not read enough bytes'), 'ERR_UNDER_READ')
+      throw new UnderReadError('Traversed entire DAG but did not read enough bytes')
     }
   }
 

packages/ipfs-unixfs-exporter/src/resolvers/unixfs-v1/content/hamt-sharded-directory.ts

@@ -1,10 +1,10 @@
 import { decode, type PBNode } from '@ipld/dag-pb'
-import errCode from 'err-code'
 import { UnixFS } from 'ipfs-unixfs'
 import map from 'it-map'
 import parallel from 'it-parallel'
 import { pipe } from 'it-pipe'
 import { CustomProgressEvent } from 'progress-events'
+import { NotUnixFSError } from '../../../errors.js'
 import type { ExporterOptions, Resolve, UnixfsV1DirectoryContent, UnixfsV1Resolver, ReadableStorage, ExportWalk } from '../../../index.js'
 
 const hamtShardedDirectoryContent: UnixfsV1Resolver = (cid, node, unixfs, path, resolve, depth, blockstore) => {
@@ -23,18 +23,18 @@ async function * listDirectory (node: PBNode, path: string, resolve: Resolve, de
   const links = node.Links
 
   if (node.Data == null) {
-    throw errCode(new Error('no data in PBNode'), 'ERR_NOT_UNIXFS')
+    throw new NotUnixFSError('no data in PBNode')
   }
 
   let dir: UnixFS
   try {
     dir = UnixFS.unmarshal(node.Data)
   } catch (err: any) {
-    throw errCode(err, 'ERR_NOT_UNIXFS')
+    throw new NotUnixFSError(err.message)
   }
 
   if (dir.fanout == null) {
-    throw errCode(new Error('missing fanout'), 'ERR_NOT_UNIXFS')
+    throw new NotUnixFSError('missing fanout')
   }
 
   const padLength = (dir.fanout - 1n).toString(16).length

packages/ipfs-unixfs-exporter/src/resolvers/unixfs-v1/index.ts

@@ -1,6 +1,6 @@
 import { decode, type PBNode } from '@ipld/dag-pb'
-import errCode from 'err-code'
 import { UnixFS } from 'ipfs-unixfs'
+import { NotFoundError, NotUnixFSError } from '../../errors.js'
 import findShardCid from '../../utils/find-cid-in-shard.js'
 import contentDirectory from './content/directory.js'
 import contentFile from './content/file.js'
@@ -39,14 +39,14 @@ const unixFsResolver: Resolver = async (cid, name, path, toResolve, resolve, dep
   }
 
   if (node.Data == null) {
-    throw errCode(new Error('no data in PBNode'), 'ERR_NOT_UNIXFS')
+    throw new NotUnixFSError('no data in PBNode')
   }
 
   try {
     unixfs = UnixFS.unmarshal(node.Data)
   } catch (err: any) {
     // non-UnixFS dag-pb node? It could happen.
-    throw errCode(err, 'ERR_NOT_UNIXFS')
+    throw new NotUnixFSError(err.message)
   }
 
   if (path == null) {
@@ -64,7 +64,7 @@ const unixFsResolver: Resolver = async (cid, name, path, toResolve, resolve, dep
     }
 
     if (linkCid == null) {
-      throw errCode(new Error('file does not exist'), 'ERR_NOT_FOUND')
+      throw new NotFoundError('file does not exist')
     }
 
     // remove the path component we have resolved
@@ -82,7 +82,7 @@ const unixFsResolver: Resolver = async (cid, name, path, toResolve, resolve, dep
   const content = contentExporters[unixfs.type](cid, node, unixfs, path, resolve, depth, blockstore)
 
   if (content == null) {
-    throw errCode(new Error('could not find content exporter'), 'ERR_NOT_FOUND')
+    throw new NotFoundError('could not find content exporter')
   }
 
   if (unixfs.isDirectory()) {

packages/ipfs-unixfs-exporter/src/utils/find-cid-in-shard.ts

@@ -1,8 +1,8 @@
 import { decode, type PBLink, type PBNode } from '@ipld/dag-pb'
 import { murmur3128 } from '@multiformats/murmur3'
-import errCode from 'err-code'
 import { Bucket, type BucketPosition, createHAMT } from 'hamt-sharding'
 import { UnixFS } from 'ipfs-unixfs'
+import { NotUnixFSError } from '../errors.js'
 import type { ExporterOptions, ShardTraversalContext, ReadableStorage } from '../index.js'
 import type { CID } from 'multiformats/cid'
 
@@ -66,21 +66,21 @@ const toBucketPath = (position: BucketPosition<boolean>): Array<Bucket<boolean>>
 const findShardCid = async (node: PBNode, name: string, blockstore: ReadableStorage, context?: ShardTraversalContext, options?: ExporterOptions): Promise<CID | undefined> => {
   if (context == null) {
     if (node.Data == null) {
-      throw errCode(new Error('no data in PBNode'), 'ERR_NOT_UNIXFS')
+      throw new NotUnixFSError('no data in PBNode')
     }
 
     let dir: UnixFS
     try {
       dir = UnixFS.unmarshal(node.Data)
     } catch (err: any) {
-      throw errCode(err, 'ERR_NOT_UNIXFS')
+      throw new NotUnixFSError(err.message)
     }
 
     if (dir.type !== 'hamt-sharded-directory') {
-      throw errCode(new Error('not a HAMT'), 'ERR_NOT_UNIXFS')
+      throw new NotUnixFSError('not a HAMT')
     }
     if (dir.fanout == null) {
-      throw errCode(new Error('missing fanout'), 'ERR_NOT_UNIXFS')
+      throw new NotUnixFSError('missing fanout')
     }
 
     const rootBucket = createHAMT<boolean>({

packages/ipfs-unixfs-exporter/src/utils/resolve-object-path.ts

@@ -1,5 +1,5 @@
-import errCode from 'err-code'
 import { CID } from 'multiformats/cid'
+import { NoPropError } from '../errors.js'
 import type { ResolveResult } from '../index.js'
 
 export function resolveObjectPath (object: any, block: Uint8Array, cid: CID, name: string, path: string, toResolve: string[], depth: number): ResolveResult {
@@ -41,7 +41,7 @@ export function resolveObjectPath (object: any, block: Uint8Array, cid: CID, nam
       subObject = subObject[prop]
     } else {
       // cannot resolve further
-      throw errCode(new Error(`No property named ${prop} found in node ${cid}`), 'ERR_NO_PROP')
+      throw new NoPropError(`No property named ${prop} found in node ${cid}`)
     }
   }