@helia/unixfs 3.0.0 → 3.0.1

package/src/commands/utils/dir-sharded.ts

@@ -7,7 +7,7 @@ import {
   hamtHashFn
 } from './hamt-constants.js'
 import { persist, type PersistOptions } from './persist.js'
-import type { Blocks } from '@helia/interface/blocks'
+import type { Blockstore } from 'interface-blockstore'
 import type { Mtime } from 'ipfs-unixfs'
 
 interface InProgressImportResult extends ImportResult {
@@ -69,7 +69,7 @@ abstract class Dir {
   abstract put (name: string, value: InProgressImportResult | Dir): Promise<void>
   abstract get (name: string): Promise<InProgressImportResult | Dir | undefined>
   abstract eachChildSeries (): AsyncIterable<{ key: string, child: InProgressImportResult | Dir }>
-  abstract flush (blockstore: Blocks): AsyncGenerator<ImportResult>
+  abstract flush (blockstore: Blockstore): AsyncGenerator<ImportResult>
   abstract estimateNodeSize (): number
   abstract childCount (): number
 }
@@ -129,7 +129,7 @@ export class DirSharded extends Dir {
     return this.nodeSize
   }
 
-  async * flush (blockstore: Blocks): AsyncGenerator<ImportResult> {
+  async * flush (blockstore: Blockstore): AsyncGenerator<ImportResult> {
     for await (const entry of flush(this._bucket, blockstore, this, this.options)) {
       yield {
         ...entry,
@@ -139,7 +139,7 @@ export class DirSharded extends Dir {
   }
 }
 
-async function * flush (bucket: Bucket<Dir | InProgressImportResult>, blockstore: Blocks, shardRoot: DirSharded | null, options: PersistOptions): AsyncIterable<ImportResult> {
+async function * flush (bucket: Bucket<Dir | InProgressImportResult>, blockstore: Blockstore, shardRoot: DirSharded | null, options: PersistOptions): AsyncIterable<ImportResult> {
   const children = bucket._children
   const links: PBLink[] = []
   let childrenSize = 0n

package/src/commands/utils/hamt-utils.ts

@@ -14,8 +14,8 @@ import {
 } from './hamt-constants.js'
 import { persist } from './persist.js'
 import type { PersistOptions } from './persist.js'
-import type { Blocks } from '@helia/interface/blocks'
 import type { AbortOptions } from '@libp2p/interface'
+import type { Blockstore } from 'interface-blockstore'
 import type { Mtime } from 'ipfs-unixfs'
 import type { ImportResult } from 'ipfs-unixfs-importer'
 import type { CID, Version } from 'multiformats/cid'
@@ -40,7 +40,7 @@ export interface CreateShardOptions {
   cidVersion: Version
 }
 
-export const createShard = async (blockstore: Blocks, contents: Array<{ name: string, size: bigint, cid: CID }>, options: CreateShardOptions): Promise<ImportResult> => {
+export const createShard = async (blockstore: Blockstore, contents: Array<{ name: string, size: bigint, cid: CID }>, options: CreateShardOptions): Promise<ImportResult> => {
   const shard = new DirSharded({
     root: true,
     dir: true,
@@ -75,7 +75,7 @@ export interface HAMTPath {
   node: dagPB.PBNode
 }
 
-export const updateShardedDirectory = async (path: HAMTPath[], blockstore: Blocks, options: PersistOptions): Promise<{ cid: CID, node: dagPB.PBNode }> => {
+export const updateShardedDirectory = async (path: HAMTPath[], blockstore: Blockstore, options: PersistOptions): Promise<{ cid: CID, node: dagPB.PBNode }> => {
   // persist any metadata on the shard root
   const shardRoot = UnixFS.unmarshal(path[0].node.Data ?? new Uint8Array(0))
 
@@ -142,7 +142,7 @@ export const updateShardedDirectory = async (path: HAMTPath[], blockstore: Block
   return { cid, node }
 }
 
-export const recreateShardedDirectory = async (cid: CID, fileName: string, blockstore: Blocks, options: AbortOptions): Promise<{ path: HAMTPath[], hash: InfiniteHash }> => {
+export const recreateShardedDirectory = async (cid: CID, fileName: string, blockstore: Blockstore, options: AbortOptions): Promise<{ path: HAMTPath[], hash: InfiniteHash }> => {
   const wrapped = wrapHash(hamtHashFn)
   const hash = wrapped(uint8ArrayFromString(fileName))
   const path: HAMTPath[] = []

package/src/commands/utils/is-over-shard-threshold.ts

@@ -1,9 +1,9 @@
 import * as dagPb from '@ipld/dag-pb'
 import { UnixFS } from 'ipfs-unixfs'
 import { CID_V0, CID_V1 } from './dir-sharded.js'
-import type { Blocks } from '@helia/interface/blocks'
 import type { PBNode } from '@ipld/dag-pb'
 import type { AbortOptions } from '@libp2p/interface'
+import type { Blockstore } from 'interface-blockstore'
 
 /**
  * Estimate node size only based on DAGLink name and CID byte lengths
@@ -11,7 +11,7 @@ import type { AbortOptions } from '@libp2p/interface'
  *
  * If the node is a hamt sharded directory the calculation is based on if it was a regular directory.
  */
-export async function isOverShardThreshold (node: PBNode, blockstore: Blocks, threshold: number, options: AbortOptions): Promise<boolean> {
+export async function isOverShardThreshold (node: PBNode, blockstore: Blockstore, threshold: number, options: AbortOptions): Promise<boolean> {
   if (node.Data == null) {
     throw new Error('DagPB node had no data')
   }
@@ -43,7 +43,7 @@ function estimateNodeSize (node: PBNode): number {
   return size
 }
 
-async function estimateShardSize (node: PBNode, current: number, max: number, blockstore: Blocks, options: AbortOptions): Promise<number> {
+async function estimateShardSize (node: PBNode, current: number, max: number, blockstore: Blockstore, options: AbortOptions): Promise<number> {
   if (current > max) {
     return max
   }

package/src/commands/utils/remove-link.ts

@@ -11,9 +11,9 @@ import {
 import { isOverShardThreshold } from './is-over-shard-threshold.js'
 import { persist } from './persist.js'
 import type { Directory } from './cid-to-directory.js'
-import type { Blocks } from '@helia/interface/blocks'
 import type { PBNode } from '@ipld/dag-pb'
 import type { AbortOptions } from '@libp2p/interface'
+import type { Blockstore } from 'interface-blockstore'
 import type { CID, Version } from 'multiformats/cid'
 
 const log = logger('helia:unixfs:utils:remove-link')
@@ -28,7 +28,7 @@ export interface RemoveLinkResult {
   cid: CID
 }
 
-export async function removeLink (parent: Directory, name: string, blockstore: Blocks, options: RmLinkOptions): Promise<RemoveLinkResult> {
+export async function removeLink (parent: Directory, name: string, blockstore: Blockstore, options: RmLinkOptions): Promise<RemoveLinkResult> {
   if (parent.node.Data == null) {
     throw new InvalidPBNodeError('Parent node had no data')
   }
@@ -54,7 +54,7 @@ export async function removeLink (parent: Directory, name: string, blockstore: B
   return removeFromDirectory(parent, name, blockstore, options)
 }
 
-const removeFromDirectory = async (parent: Directory, name: string, blockstore: Blocks, options: AbortOptions): Promise<RemoveLinkResult> => {
+const removeFromDirectory = async (parent: Directory, name: string, blockstore: Blockstore, options: AbortOptions): Promise<RemoveLinkResult> => {
   // Remove existing link if it exists
   parent.node.Links = parent.node.Links.filter((link) => {
     return link.Name !== name
@@ -74,7 +74,7 @@ const removeFromDirectory = async (parent: Directory, name: string, blockstore:
   }
 }
 
-const removeFromShardedDirectory = async (parent: Directory, name: string, blockstore: Blocks, options: UpdateHamtDirectoryOptions): Promise<{ cid: CID, node: PBNode }> => {
+const removeFromShardedDirectory = async (parent: Directory, name: string, blockstore: Blockstore, options: UpdateHamtDirectoryOptions): Promise<{ cid: CID, node: PBNode }> => {
   const { path } = await recreateShardedDirectory(parent.cid, name, blockstore, options)
   const finalSegment = path[path.length - 1]
 
@@ -131,7 +131,7 @@ const removeFromShardedDirectory = async (parent: Directory, name: string, block
   return updateShardedDirectory(path, blockstore, options)
 }
 
-const convertToFlatDirectory = async (parent: Directory, blockstore: Blocks, options: RmLinkOptions): Promise<RemoveLinkResult> => {
+const convertToFlatDirectory = async (parent: Directory, blockstore: Blockstore, options: RmLinkOptions): Promise<RemoveLinkResult> => {
   if (parent.node.Data == null) {
     throw new InvalidParametersError('Invalid parent passed to convertToFlatDirectory')
   }

package/src/commands/utils/resolve.ts

@@ -1,11 +1,12 @@
 import { logger } from '@libp2p/logger'
-import { exporter } from 'ipfs-unixfs-exporter'
-import { DoesNotExistError, InvalidParametersError } from '../../errors.js'
+import { walkPath } from 'ipfs-unixfs-exporter'
+import all from 'it-all'
+import { DoesNotExistError } from '../../errors.js'
 import { addLink } from './add-link.js'
 import { cidToDirectory } from './cid-to-directory.js'
 import { cidToPBLink } from './cid-to-pblink.js'
-import type { Blocks } from '@helia/interface/blocks'
 import type { AbortOptions } from '@libp2p/interface'
+import type { Blockstore } from 'interface-blockstore'
 import type { CID } from 'multiformats/cid'
 
 const log = logger('helia:unixfs:components:utils:resolve')
@@ -32,62 +33,22 @@ export interface ResolveResult {
   segments?: Segment[]
 }
 
-export async function resolve (cid: CID, path: string | undefined, blockstore: Blocks, options: AbortOptions): Promise<ResolveResult> {
+export async function resolve (cid: CID, path: string | undefined, blockstore: Blockstore, options: AbortOptions): Promise<ResolveResult> {
   if (path == null || path === '') {
     return { cid }
   }
 
-  log('resolve "%s" under %c', path, cid)
-
-  const parts = path.split('/').filter(Boolean)
-  const segments: Segment[] = [{
-    name: '',
-    cid,
-    size: 0n
-  }]
-
-  for (let i = 0; i < parts.length; i++) {
-    const part = parts[i]
-    const result = await exporter(cid, blockstore, options)
-
-    log('resolving "%s"', part, result)
-
-    if (result.type === 'file') {
-      if (i < parts.length - 1) {
-        throw new InvalidParametersError('Path was invalid')
-      }
-
-      cid = result.cid
-    } else if (result.type === 'directory') {
-      let dirCid: CID | undefined
-
-      for await (const entry of result.content()) {
-        if (entry.name === part) {
-          dirCid = entry.cid
-          break
-        }
-      }
-
-      if (dirCid == null) {
-        throw new DoesNotExistError('Could not find path in directory')
-      }
-
-      cid = dirCid
-
-      segments.push({
-        name: part,
-        cid,
-        size: result.size
-      })
-    } else {
-      throw new InvalidParametersError('Could not resolve path')
-    }
+  const p = `/ipfs/${cid}${path == null ? '' : `/${path}`}`
+  const segments = await all(walkPath(p, blockstore, options))
+
+  if (segments.length === 0) {
+    throw new DoesNotExistError('Could not find path in directory')
   }
 
   log('resolved %s to %c', path, cid)
 
   return {
-    cid,
+    cid: segments[segments.length - 1].cid,
     path,
     segments
   }
@@ -101,7 +62,7 @@ export interface UpdatePathCidsOptions extends AbortOptions {
  * Where we have descended into a DAG to update a child node, ascend up the DAG creating
  * new hashes and blocks for the changed content
  */
-export async function updatePathCids (cid: CID, result: ResolveResult, blockstore: Blocks, options: UpdatePathCidsOptions): Promise<CID> {
+export async function updatePathCids (cid: CID, result: ResolveResult, blockstore: Blockstore, options: UpdatePathCidsOptions): Promise<CID> {
   if (result.segments == null || result.segments.length === 0) {
     return cid
   }

package/src/index.ts

@@ -52,8 +52,9 @@ import { mkdir } from './commands/mkdir.js'
 import { rm } from './commands/rm.js'
 import { stat } from './commands/stat.js'
 import { touch } from './commands/touch.js'
-import type { Blocks, GetBlockProgressEvents, PutBlockProgressEvents } from '@helia/interface/blocks'
+import type { GetBlockProgressEvents, PutBlockProgressEvents } from '@helia/interface/blocks'
 import type { AbortOptions } from '@libp2p/interface'
+import type { Blockstore } from 'interface-blockstore'
 import type { Mtime, UnixFS as IPFSUnixFS } from 'ipfs-unixfs'
 import type { ExporterProgressEvents, UnixFSEntry } from 'ipfs-unixfs-exporter'
 import type { ByteStream, DirectoryCandidate, FileCandidate, ImportCandidateStream, ImporterOptions, ImporterProgressEvents, ImportResult } from 'ipfs-unixfs-importer'
@@ -61,7 +62,7 @@ import type { CID, Version } from 'multiformats/cid'
 import type { ProgressOptions } from 'progress-events'
 
 export interface UnixFSComponents {
-  blockstore: Blocks
+  blockstore: Blockstore
 }
 
 export type AddEvents = PutBlockProgressEvents
@@ -616,7 +617,7 @@ class DefaultUnixFS implements UnixFS {
 /**
  * Create a {@link UnixFS} instance for use with {@link https://github.com/ipfs/helia Helia}
  */
-export function unixfs (helia: { blockstore: Blocks }): UnixFS {
+export function unixfs (helia: { blockstore: Blockstore }): UnixFS {
   return new DefaultUnixFS(helia)
 }