corestore 7.4.8 → 7.5.0

package/README.md

@@ -5,12 +5,14 @@
 Corestore is a Hypercore factory that makes it easier to manage large collections of named Hypercores.
 
 Corestore provides:
-1. __Key Derivation__ - All writable Hypercore keys are derived from a single master key and a user-provided name.
-2. __Session Handling__ - If a single Hypercore is loaded multiple times through the `get` method, the underlying resources will only be opened once (using Hypercore 10's new session feature). Once all sessions are closed, the resources will be released.
-3. __Storage Management__ - Hypercores can be stored in any `hypercore-storage` instance, where they will be keyed by their discovery keys.
-4. __Namespacing__ - You can share a single Corestore instance between multiple applications or components without worrying about naming collisions by creating "namespaces" (e.g. `corestore.namespace('my-app').get({ name: 'main' })`)
+
+1. **Key Derivation** - All writable Hypercore keys are derived from a single master key and a user-provided name.
+2. **Session Handling** - If a single Hypercore is loaded multiple times through the `get` method, the underlying resources will only be opened once (using Hypercore 10's new session feature). Once all sessions are closed, the resources will be released.
+3. **Storage Management** - Hypercores can be stored in any `hypercore-storage` instance, where they will be keyed by their discovery keys.
+4. **Namespacing** - You can share a single Corestore instance between multiple applications or components without worrying about naming collisions by creating "namespaces" (e.g. `corestore.namespace('my-app').get({ name: 'main' })`)
 
 ### Installation
+
 `npm install corestore`
 
 > [!NOTE]
@@ -19,7 +21,9 @@ Corestore provides:
 > It will be updated to 11 in a few weeks.
 
 ### Usage
+
 A corestore instance can be constructed with a `hypercore-storage` instance, or a string. If a string is specified, it will be assumed to be a path to a local storage directory:
+
 ```js
 const Corestore = require('corestore')
 
@@ -46,6 +50,7 @@ Options:
 ```
 
 #### `const core = store.get(key | { name: 'a-name', ...hypercoreOpts})`
+
 Loads a Hypercore, either by name (if the `name` option is provided), or from the provided key (if the first argument is a Buffer or String with hex/z32 key, or if the `key` options is set).
 
 If that Hypercore has previously been loaded, subsequent calls to `get` will return a new Hypercore session on the existing core.
@@ -53,6 +58,7 @@ If that Hypercore has previously been loaded, subsequent calls to `get` will ret
 All other options besides `name` and `key` will be forwarded to the Hypercore constructor.
 
 #### `const stream = store.replicate(optsOrStream)`
+
 Creates a replication stream that's capable of replicating all Hypercores that are managed by the Corestore, assuming the remote peer has the correct capabilities.
 
 `opts` will be forwarded to Hypercore's `replicate` function.
@@ -63,7 +69,7 @@ If the remote side dynamically adds a new Hypercore to the replication stream, C
 
 Using [Hyperswarm](https://github.com/holepunchto/hyperswarm) you can easily replicate corestores
 
-``` js
+```js
 const swarm = new Hyperswarm()
 
 // join the relevant topic
@@ -74,12 +80,15 @@ swarm.on('connection', (connection) => store.replicate(connection))
 ```
 
 #### `const storeB = storeA.session()`
+
 Create a new Corestore session. Closing a session will close all cores made from this session.
 
 #### `const store = store.namespace(name)`
+
 Create a new namespaced Corestore session. Namespacing is useful if you're going to be sharing a single Corestore instance between many applications or components, as it prevents name collisions.
 
 Namespaces can be chained:
+
 ```js
 const ns1 = store.namespace('a')
 const ns2 = ns1.namespace('b')
@@ -88,9 +97,11 @@ const core2 = ns2.get({ name: 'main' })
 ```
 
 #### `const stream = store.list(namespace)`
+
 Creates a discovery key stream of all cores within a namespace or all cores in general if no namespace is provided.
 
 #### `store.watch((core) => {})`
+
 Register a callback called when new Hypercores are opened. `core` is the internal core for the opened Hypercore. It can be used to create weak references to a Hypercore like so:
 
 ```
@@ -100,21 +111,27 @@ store.watch(function (core) {
 ```
 
 #### `store.unwatch(callback)`
+
 Unregister a callback used with `store.watch(callback)` so it no longer fires.
 
 #### `await store.suspend()`
+
 Suspend the underlying storage for the Corestore.
 
 #### `await store.resume()`
+
 Resume a suspended Corestore.
 
 #### `const keypair = await store.createKeyPair(name, ns = this.ns)`
+
 Generate a key pair seeded with the Corestore's primary key using a `name` and a `ns` aka namespace. `ns` defaults to the current namespace.
 
 This is useful for creating deterministic key pairs that are unique to a peer.
 
 #### `await store.close()`
+
 Fully close this Corestore instance.
 
 ### License
+
 MIT

package/index.js

@@ -13,23 +13,23 @@ const [NS] = crypto.namespace('corestore', 1)
 const DEFAULT_NAMESPACE = b4a.alloc(32) // This is meant to be 32 0-bytes
 
 class StreamTracker {
-  constructor () {
+  constructor() {
     this.records = []
   }
 
-  add (stream, isExternal) {
+  add(stream, isExternal) {
     const record = { index: 0, stream, isExternal }
     record.index = this.records.push(record) - 1
     return record
   }
 
-  remove (record) {
+  remove(record) {
     const popped = this.records.pop()
     if (popped === record) return
     this.records[(popped.index = record.index)] = popped
   }
 
-  attachAll (core) {
+  attachAll(core) {
     for (let i = 0; i < this.records.length; i++) {
       const record = this.records[i]
       const muxer = record.stream.noiseStream.userData
@@ -37,7 +37,7 @@ class StreamTracker {
     }
   }
 
-  destroy () {
+  destroy() {
     // reverse is safer cause we delete mb
     for (let i = this.records.length - 1; i >= 0; i--) {
       const record = this.records[i]
@@ -47,15 +47,15 @@ class StreamTracker {
 }
 
 class SessionTracker {
-  constructor () {
+  constructor() {
     this.map = new Map()
   }
 
-  get size () {
+  get size() {
     return this.map.size
   }
 
-  get (id) {
+  get(id) {
     const existing = this.map.get(id)
     if (existing !== undefined) return existing
     const fresh = []
@@ -63,23 +63,23 @@ class SessionTracker {
     return fresh
   }
 
-  gc (id) {
+  gc(id) {
     this.map.delete(id)
   }
 
-  list (id) {
-    return id ? (this.map.get(id) || []) : [...this]
+  list(id) {
+    return id ? this.map.get(id) || [] : [...this]
   }
 
-  * [Symbol.iterator] () {
+  *[Symbol.iterator]() {
     for (const sessions of this.map.values()) {
-      yield * sessions[Symbol.iterator]()
+      yield* sessions[Symbol.iterator]()
     }
   }
 }
 
 class CoreTracker {
-  constructor () {
+  constructor() {
     this.map = new Map()
     this.watching = []
 
@@ -88,23 +88,23 @@ class CoreTracker {
     this._gcCycleBound = this._gcCycle.bind(this)
   }
 
-  get size () {
+  get size() {
     return this.map.size
   }
 
-  watch (store) {
+  watch(store) {
     if (store.watchIndex !== -1) return
     store.watchIndex = this.watching.push(store) - 1
   }
 
-  unwatch (store) {
+  unwatch(store) {
     if (store.watchIndex === -1) return
     const head = this.watching.pop()
     if (head !== store) this.watching[(head.watchIndex = store.watchIndex)] = head
     store.watchIndex = -1
   }
 
-  resume (id) {
+  resume(id) {
     const core = this.map.get(id)
 
     if (!core) return null
@@ -121,12 +121,12 @@ class CoreTracker {
     return core
   }
 
-  opened (id) {
+  opened(id) {
     const core = this.map.get(id)
     return !!(core && core.opened && !core.closing)
   }
 
-  get (id) {
+  get(id) {
     // we allow you do call this from the outside, so support normal buffers also
     if (b4a.isBuffer(id)) id = b4a.toString(id, 'hex')
     const core = this.map.get(id)
@@ -134,24 +134,24 @@ class CoreTracker {
     return core
   }
 
-  set (id, core) {
+  set(id, core) {
     this.map.set(id, core)
     if (this.watching.length > 0) this._emit(core)
   }
 
-  _emit (core) {
+  _emit(core) {
     for (let i = this.watching.length - 1; i >= 0; i--) {
       const store = this.watching[i]
       for (const fn of store.watchers) fn(core)
     }
   }
 
-  _gc (core) {
+  _gc(core) {
     const id = toHex(core.discoveryKey)
     if (this.map.get(id) === core) this.map.delete(id)
   }
 
-  _gcCycle () {
+  _gcCycle() {
     for (const core of this._gcing) {
       if (++core.gc < 4) continue
       const gc = this._gc.bind(this, core)
@@ -162,24 +162,24 @@ class CoreTracker {
     if (this._gcing.size === 0) this._stopGC()
   }
 
-  gc (core) {
+  gc(core) {
     core.gc = 1 // first strike
     this._gcing.add(core)
     if (this._gcing.size === 1) this._startGC()
   }
 
-  _stopGC () {
+  _stopGC() {
     clearInterval(this._gcInterval)
     this._gcInterval = null
   }
 
-  _startGC () {
+  _startGC() {
     if (this._gcInterval) return
     this._gcInterval = setInterval(this._gcCycleBound, 2000)
     if (this._gcInterval.unref) this._gcInterval.unref()
   }
 
-  close () {
+  close() {
     this._stopGC()
     this._gcing.clear()
 
@@ -193,7 +193,7 @@ class CoreTracker {
     return Promise.all(all)
   }
 
-  * [Symbol.iterator] () {
+  *[Symbol.iterator]() {
     for (const core of this.map.values()) {
       if (!core.closing) yield core
     }
@@ -201,17 +201,17 @@ class CoreTracker {
 }
 
 class FindingPeers {
-  constructor () {
+  constructor() {
     this.count = 0
     this.pending = []
   }
 
-  add (core) {
+  add(core) {
     if (this.count === 0) return
     this.pending.push(core.findingPeers())
   }
 
-  inc (sessions) {
+  inc(sessions) {
     if (++this.count !== 1) return
 
     for (const core of sessions) {
@@ -219,25 +219,31 @@ class FindingPeers {
     }
   }
 
-  dec (sessions) {
+  dec(sessions) {
     if (--this.count !== 0) return
     while (this.pending.length > 0) this.pending.pop()()
   }
 }
 
 class Corestore extends ReadyResource {
-  constructor (storage, opts = {}) {
+  constructor(storage, opts = {}) {
     super()
 
     this.root = opts.root || null
-    this.storage = this.root ? this.root.storage : Hypercore.defaultStorage(storage, { id: opts.id, allowBackup: opts.allowBackup, readOnly: opts.readOnly })
+    this.storage = this.root
+      ? this.root.storage
+      : Hypercore.defaultStorage(storage, {
+          id: opts.id,
+          allowBackup: opts.allowBackup,
+          readOnly: opts.readOnly
+        })
     this.streamTracker = this.root ? this.root.streamTracker : new StreamTracker()
     this.cores = this.root ? this.root.cores : new CoreTracker()
     this.sessions = new SessionTracker()
     this.corestores = this.root ? this.root.corestores : new Set()
     this.readOnly = opts.writable === false || !!opts.readOnly
-    this.globalCache = this.root ? this.root.globalCache : (opts.globalCache || null)
-    this.primaryKey = this.root ? this.root.primaryKey : (opts.primaryKey || null)
+    this.globalCache = this.root ? this.root.globalCache : opts.globalCache || null
+    this.primaryKey = this.root ? this.root.primaryKey : opts.primaryKey || null
     this.ns = opts.namespace || DEFAULT_NAMESPACE
     this.manifestVersion = opts.manifestVersion || 1
     this.shouldSuspend = isAndroid ? !!opts.suspend : opts.suspend !== false
@@ -254,7 +260,7 @@ class Corestore extends ReadyResource {
     this.ready().catch(noop)
   }
 
-  watch (fn) {
+  watch(fn) {
     if (this.watchers === null) {
       this.watchers = new Set()
       this.cores.watch(this)
@@ -263,7 +269,7 @@ class Corestore extends ReadyResource {
     this.watchers.add(fn)
   }
 
-  unwatch (fn) {
+  unwatch(fn) {
     if (this.watchers === null) return
 
     this.watchers.delete(fn)
@@ -274,7 +280,7 @@ class Corestore extends ReadyResource {
     }
   }
 
-  findingPeers () {
+  findingPeers() {
     if (this._findingPeers === null) this._findingPeers = new FindingPeers()
     this._findingPeers.inc(this.sessions)
     let done = false
@@ -285,51 +291,59 @@ class Corestore extends ReadyResource {
     }
   }
 
-  audit (opts = {}) {
+  audit(opts = {}) {
     return auditStore(this, opts)
   }
 
-  async suspend ({ log = noop } = {}) {
+  async suspend({ log = noop } = {}) {
     await log('Flushing db...')
-    await this.storage.db.flush()
+    // If readOnly we don't need to flush
+    if (!this.storage.readOnly) await this.storage.db.flush()
     if (!this.shouldSuspend) return
     await log('Suspending db...')
     await this.storage.db.suspend()
   }
 
-  resume () {
+  resume() {
     return this.storage.db.resume()
   }
 
-  session (opts) {
+  session(opts) {
     this._maybeClosed()
     const root = this.root || this
-    return new Corestore(null, { manifestVersion: this.manifestVersion, ...opts, root })
+    return new Corestore(null, {
+      manifestVersion: this.manifestVersion,
+      ...opts,
+      root
+    })
   }
 
-  namespace (name, opts) {
-    return this.session({ ...opts, namespace: generateNamespace(this.ns, name) })
+  namespace(name, opts) {
+    return this.session({
+      ...opts,
+      namespace: generateNamespace(this.ns, name)
+    })
   }
 
-  list (namespace) {
+  list(namespace) {
     return this.storage.createDiscoveryKeyStream(namespace)
   }
 
-  getAuth (discoveryKey) {
+  getAuth(discoveryKey) {
     return this.storage.getAuth(discoveryKey)
   }
 
-  _ongc (session) {
+  _ongc(session) {
     if (session.sessions.length === 0) this.sessions.gc(session.id)
   }
 
-  async _getOrSetSeed () {
+  async _getOrSetSeed() {
     const seed = await this.storage.getSeed()
     if (seed !== null) return seed
     return await this.storage.setSeed(this.primaryKey || crypto.randomBytes(32))
   }
 
-  async _open () {
+  async _open() {
     if (this.root !== null) {
       if (this.root.opened === false) await this.root.ready()
       this.primaryKey = this.root.primaryKey
@@ -348,7 +362,7 @@ class Corestore extends ReadyResource {
     }
   }
 
-  async _close () {
+  async _close() {
     const closing = []
     const hanging = [...this.sessions]
     for (const sess of hanging) closing.push(sess.close())
@@ -370,9 +384,13 @@ class Corestore extends ReadyResource {
     await this.storage.close()
   }
 
-  async _attachMaybe (muxer, discoveryKey) {
+  async _attachMaybe(muxer, discoveryKey) {
     if (this.opened === false) await this.ready()
-    if (!this.cores.opened(toHex(discoveryKey)) && !(await this.storage.has(discoveryKey, { ifMigrated: true }))) return
+    if (
+      !this.cores.opened(toHex(discoveryKey)) &&
+      !(await this.storage.has(discoveryKey, { ifMigrated: true }))
+    )
+      return
     if (this.closing) return
 
     const core = this._openCore(discoveryKey, { createIfMissing: false })
@@ -387,13 +405,19 @@ class Corestore extends ReadyResource {
     core.checkIfIdle()
   }
 
-  replicate (isInitiator, opts) {
+  _shouldReplicate(core, muxer) {
+    return (
+      core.replicator.downloading && !core.replicator.attached(muxer) && core.opened && this.active
+    )
+  }
+
+  replicate(isInitiator, opts) {
     this._maybeClosed()
 
     const isExternal = isStream(isInitiator)
     const stream = Hypercore.createProtocolStream(isInitiator, {
       ...opts,
-      ondiscoverykey: discoveryKey => {
+      ondiscoverykey: (discoveryKey) => {
         if (this.closing) return
         const muxer = stream.noiseStream.userData
         return this._attachMaybe(muxer, discoveryKey)
@@ -406,7 +430,9 @@ class Corestore extends ReadyResource {
       muxer.cork()
 
       for (const core of this.cores) {
-        if (!core.replicator.downloading || core.replicator.attached(muxer) || !core.opened || !this.active) continue
+        if (!this._shouldReplicate(core, muxer)) {
+          continue
+        }
         core.replicator.attachTo(muxer)
       }
 
@@ -418,13 +444,13 @@ class Corestore extends ReadyResource {
     return stream
   }
 
-  _maybeClosed () {
+  _maybeClosed() {
     if (this.closing || (this.root !== null && this.root.closing)) {
       throw new Error('Corestore is closed')
     }
   }
 
-  get (opts) {
+  get(opts) {
     this._maybeClosed()
 
     if (b4a.isBuffer(opts) || typeof opts === 'string') opts = { key: opts }
@@ -473,28 +499,30 @@ class Corestore extends ReadyResource {
     return this._makeSession(conf)
   }
 
-  _makeSession (conf) {
+  _makeSession(conf) {
     const session = new Hypercore(null, null, conf)
     if (this._findingPeers !== null) this._findingPeers.add(session)
     return session
   }
 
-  async createKeyPair (name, ns = this.ns) {
+  async createKeyPair(name, ns = this.ns) {
     if (this.opened === false) await this.ready()
     return createKeyPair(this.primaryKey, ns, name)
   }
 
-  async _preloadCheckIfExists (opts) {
+  async _preloadCheckIfExists(opts) {
     const has = await this.storage.has(opts.discoveryKey)
     if (!has) throw STORAGE_EMPTY('No Hypercore is stored here')
     return this._preload(opts)
   }
 
-  async _preload (opts) {
+  async _preload(opts) {
     if (opts.preload) opts = { ...opts, ...(await opts.preload) }
     if (this.opened === false) await this.ready()
 
-    const discoveryKey = opts.name ? await this.storage.getAlias({ name: opts.name, namespace: this.ns }) : null
+    const discoveryKey = opts.name
+      ? await this.storage.getAlias({ name: opts.name, namespace: this.ns })
+      : null
     this._maybeClosed()
 
     const core = this._openCore(discoveryKey, opts)
@@ -509,7 +537,7 @@ class Corestore extends ReadyResource {
     }
   }
 
-  _auth (discoveryKey, opts) {
+  _auth(discoveryKey, opts) {
     const result = {
       keyPair: null,
       key: null,
@@ -526,7 +554,10 @@ class Corestore extends ReadyResource {
     if (opts.manifest) {
       result.manifest = opts.manifest
     } else if (result.keyPair && !result.discoveryKey) {
-      result.manifest = { version: this.manifestVersion, signers: [{ publicKey: result.keyPair.publicKey }] }
+      result.manifest = {
+        version: this.manifestVersion,
+        signers: [{ publicKey: result.keyPair.publicKey }]
+      }
     }
 
     if (opts.key) result.key = ID.decode(opts.key)
@@ -541,7 +572,7 @@ class Corestore extends ReadyResource {
     return result
   }
 
-  _openCore (discoveryKey, opts) {
+  _openCore(discoveryKey, opts) {
     const auth = this._auth(discoveryKey, opts)
 
     const id = toHex(auth.discoveryKey)
@@ -549,7 +580,7 @@ class Corestore extends ReadyResource {
     if (existing && !existing.closing) return existing
 
     const core = Hypercore.createCore(this.storage, {
-      preopen: (existing && existing.opened) ? existing.closing : null, // always wait for the prev one to close first in any case...
+      preopen: existing && existing.opened ? existing.closing : null, // always wait for the prev one to close first in any case...
       eagerUpgrade: true,
       notDownloadingLinger: opts.notDownloadingLinger,
       allowFork: opts.allowFork !== false,
@@ -582,25 +613,25 @@ class Corestore extends ReadyResource {
 
 module.exports = Corestore
 
-function isStream (s) {
+function isStream(s) {
   return typeof s === 'object' && s && typeof s.pipe === 'function'
 }
 
-function generateNamespace (namespace, name) {
+function generateNamespace(namespace, name) {
   if (!b4a.isBuffer(name)) name = b4a.from(name)
   const out = b4a.allocUnsafeSlow(32)
   sodium.crypto_generichash_batch(out, [namespace, name])
   return out
 }
 
-function deriveSeed (primaryKey, namespace, name) {
+function deriveSeed(primaryKey, namespace, name) {
   if (!b4a.isBuffer(name)) name = b4a.from(name)
   const out = b4a.alloc(32)
   sodium.crypto_generichash_batch(out, [NS, namespace, name], primaryKey)
   return out
 }
 
-function createKeyPair (primaryKey, namespace, name) {
+function createKeyPair(primaryKey, namespace, name) {
   const seed = deriveSeed(primaryKey, namespace, name)
   const buf = b4a.alloc(sodium.crypto_sign_PUBLICKEYBYTES + sodium.crypto_sign_SECRETKEYBYTES)
   const keyPair = {
@@ -611,8 +642,8 @@ function createKeyPair (primaryKey, namespace, name) {
   return keyPair
 }
 
-function noop () {}
+function noop() {}
 
-function toHex (discoveryKey) {
+function toHex(discoveryKey) {
   return b4a.toString(discoveryKey, 'hex')
 }

package/lib/audit.js

@@ -1,4 +1,4 @@
-module.exports = async function * audit (store, { dryRun = false } = {}) {
+module.exports = async function* audit(store, { dryRun = false } = {}) {
   for await (const { discoveryKey, core } of store.storage.createCoreStream()) {
     if (core.version < 1) continue // not migrated, ignore
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "corestore",
-  "version": "7.4.8",
+  "version": "7.5.0",
   "description": "A Hypercore factory that simplifies managing collections of cores.",
   "main": "index.js",
   "files": [
@@ -19,12 +19,14 @@
   },
   "devDependencies": {
     "brittle": "^3.7.0",
+    "prettier": "^3.6.2",
+    "prettier-config-holepunch": "^2.0.0",
     "rache": "^1.0.0",
-    "standard": "^17.1.2",
     "test-tmp": "^1.3.0"
   },
   "scripts": {
-    "test": "standard && brittle test/*.js",
+    "format": "prettier --write .",
+    "test": "prettier --check . && brittle test/*.js",
     "test:bare": "bare test/basic.js"
   },
   "repository": {