Hyperdrive-ln NPM

hyperdrive-ln

create symbolic link between hyperdrives

npm i hyperdrive-ln

Usage

const ln = require('hyperdrive-ln')

var drive = hyperdrive(memdb())
var archive = drive.createArchive()

ln.link(archive, 'linkfile', <ARCHIVE KEY>, [meta], err => {}) // create symlink to another archive
ln.readlink(archive, 'linkfile', (err, link) => {}) // get link data

// assume ln.link(archive, 'path/to/file', <ARCHIVE KEY>)
ln.resolve(archive, 'path/to/file/within/linked/archive', (err, link, restOfThePath)) // returns (err, {link: <ARCHIVE_KEY>, meta: {...}}, 'within/linked/archive')

// resolve through archives
ln.deepResolve(drive, swarmer, archive, path, (err, result) => {})

ln.encode(key, [meta]) // encode a key for linkfile
ln.decode(data) // decode a linkfile content to key

API

`ln.link(archive, path, archiveKey, [meta], cb)`

Create a symlink at path point to archiveKey.

You can pass a meta object to store it in the symlink.

`ln.readlink(archive, path, cb)`

Get the link data stored inside a symlink.

`ln.resolve(archive, path, cb)`

Resolve a path. Returns an archive and a path within that archive with cb(err, linkedArchiveKey, pathWithinLinkedArchive)

If there's a symlink encountered in the path. cb(err, link, pathWithinLinkedArchive) will be invoked.
If there's no symlink in the path, cb(err, {}, path) will be called.

for example:

ln.link(archive, 'foo/bar', '<LINK_KEY>', (err) => {
    ln.resolve(archive, 'foo/bar/baz', (err, link, path) => {
      // link === {link: '<LINK_KEY>', meta: {...}}
      // path === 'baz'
    })
})

`ln.deepResolve(drive, swarmer, archive, path, cb)`

Recursively resolve a path through archives. Create swarm connection when necessary.

swarmer is anything let you join swarm . For example: hyperdiscovery.

callback cb(err, result) where result is a recursive structure:

{
  archive: // traversed archive,
  path: // consumed path,
  swarm: // swarm instance,
  next: result // next component if there's one
}

For example: Assume we have an archive1 which /foo/bar linked to archive2.

ln.deepResolve(drive, swarmer, archive1, '/foo/bar/baz/baz.txt', cb)

will get the result:

{
  archive: archive1,
  path: '/foo/bar',
  swarm: // a swarm instance,
  next: {
    archive: archive2,
    path: 'baz/baz.txt',
    swarm: // another swarm instance
  }
}

use deepClose(result) to close all swarm instance in the result.