MirrorDrive

stable

Mirrordrive computes diffs between two drive-like APIs and applies them efficiently. It is the helper that powers sync flows between Hyperdrive and Localdrive, including the drive.mirror(...) shortcut on Hyperdrive. A MirrorDrive instance is itself an async iterator, so iterating it with for await (const diff of mirror) drives the diff/copy pass and yields one diff object per entry. For source and release notes, see the mirror-drive repository.

Async iteration

`for await (const diff of mirror)`

MirrorDrive is itself an async iterable. Iterating it with for await drives the entire diff/copy pass; each yield produces one { op, key } object where op is 'put' or 'del'.

for await (const diff of mirror) {
  console.log(diff.op, diff.key)
}

Option patterns

`transformers`

API definition on GitHub

Returns: A copy pipeline hook. Each transformer is a function (key) => stream | null; returning null skips that transform for the current file.
Example:

const mirror = new MirrorDrive(src, dst, {
  transformers: [
    (key) => key.endsWith('.txt') ? myTransformStream() : null
  ]
})

`entries`

API definition on GitHub

Returns: A fixed list of entries to mirror instead of reading them from src.list(...). When this option is used, prefix is ignored.
Example:

const entries = [{ key: '/index.html' }, { key: '/styles.css' }]
const mirror = new MirrorDrive(src, dst, { entries })

`metadataEquals`

API definition on GitHub

Returns: A predicate used to decide whether metadata changes should count as a diff when both drives support metadata.
Example:

const mirror = new MirrorDrive(src, dst, {
  metadataEquals(left, right) {
    return JSON.stringify(left) === JSON.stringify(right)
  }
})

Install

npm i mirror-drive

Quickstart

import Corestore from 'corestore'
import Hyperdrive from 'hyperdrive'
import Localdrive from 'localdrive'
import MirrorDrive from 'mirror-drive'

const store = new Corestore('./storage')
const src = new Localdrive('./site')
const dst = new Hyperdrive(store)

await dst.ready()

const mirror = new MirrorDrive(src, dst, { prune: true })

for await (const diff of mirror) {
  console.log(diff)
}

Parameter	Type	Default	Description
`src`	`Hyperdrive\|Localdrive`	—	Source drive to read from.
`dst`	`Hyperdrive\|Localdrive`	—	Destination drive to write into (must be writable).
`options`	`MirrorDriveOptions`	`{}`	Mirror options.

Property	Type	Default	Description
`prefix`	`string\|Array<string>`	`'/'`	One or more path prefixes to mirror. When an array, each prefix is mirrored in order.
`dryRun`	`boolean`	`false`	Walk the diff and emit events without writing any changes to `dst`.
`prune`	`boolean`	`true`	Remove files from `dst` that no longer exist in `src`.
`includeEquals`	`boolean`	`false`	Emit `{ op: 'equal' }` events for files that are identical in both drives.
`filter`	`function(string): boolean`	—	Called with each source key; return `false` to skip that entry.
`metadataEquals`	`function(,): boolean`	—	Custom equality check for file metadata; receives `(srcMetadata, dstMetadata)`.
`batch`	`boolean`	`false`	Accumulate destination writes in a single batch and flush at the end.
`entries`	`Array<object>\|null`	`null`	Pre-computed list of source entries to mirror; when provided, `prefix` is ignored.
`ignore`	`string\|Array<string>`	—	Path(s) to exclude from the source listing.
`transformers`	`Array<function>`	`[]`	Array of factory functions `(key) => stream \| null`; each returned stream is piped between source read and destination write.
`progress`	`boolean`	`false`	Enable download/upload progress tracking (requires `src.getBlobs`).
`dedup`	`boolean`	`false`	Enable content-addressed deduplication using Rabin chunking on the destination.

MirrorDrive

On this page