index.js

const path = require('path')

// This is a dirty hack for browserify to work. 😅
if (!path.posix) path.posix = path

const SwarmNetworker = require('corestore-swarm-networking')
const RAA = require('random-access-application')
const DatEncoding = require('dat-encoding')
const crypto = require('hypercore-crypto')
const RAM = require('random-access-memory')
const HypercoreProtocol = require('hypercore-protocol')

const datDNS = require('dat-dns')
const makeHyperdrive = require('hyperdrive')
const Corestore = require('corestore')
const makeHypercore = require('hypercore')

const DEFAULT_SWARM_OPTS = {
  extensions: []
}
const DEFAULT_DRIVE_OPTS = {
  sparse: true,
  persist: true
}
const DEFAULT_CORE_OPTS = {
  sparse: true,
  persist: true
}
const DEFAULT_DNS_OPTS = {}
const DEFAULT_CORESTORE_OPTS = {
  sparse: true
}

const DEFAULT_APPLICATION_NAME = 'dat-sdk'

module.exports = SDK

// TODO: Set up Promise API based on Beaker https://github.com/beakerbrowser/beaker/blob/blue-hyperdrive10/app/bg/web-apis/fg/hyperdrive.js

async function SDK ({
  storage,
  corestore,
  applicationName = DEFAULT_APPLICATION_NAME,
  swarmOpts,
  driveOpts,
  coreOpts,
  dnsOpts,
  corestoreOpts
} = {}
) {
  // Derive storage if it isn't provided
  // Don't derive if corestore was provided
  if (!storage && !corestore) storage = RAA(applicationName)

  if (!corestore) {
    corestore = new Corestore(
      storage,
      Object.assign({}, DEFAULT_CORESTORE_OPTS, corestoreOpts)
    )
  }

  const swarm = new SwarmNetworker(corestore, Object.assign({}, DEFAULT_SWARM_OPTS, swarmOpts))
  const dns = datDNS(Object.assign({}, DEFAULT_DNS_OPTS, dnsOpts))

  // Track list of hyperdrives
  const drives = new Map()
  const cores = new Map()

  await corestore.ready()

  // I think this is used to create a persisted identity?
  const noiseSeed = corestore._deriveSecret(applicationName, 'replication-keypair')
  swarm.listen({
    keyPair: HypercoreProtocol.keyPair(noiseSeed)
  })

  return {
    Hyperdrive,
    Hypercore,
    resolveName,
    deleteStorage,
    destroy,
    _storage: storage,
    _corestore: corestore,
    _swarm: swarm,
    _dns: dns
  }

  function destroy (cb) {
    for (const drive of drives.values()) {
      drive.close()
    }

    for (const core of cores.values()) {
      core.close()
    }

    swarm.close().then(cb, cb)
  }

  function resolveName (url, cb) {
    return dns.resolveName(url, cb)
  }

  function deleteStorage (key, cb) {
    storage.delete(key, cb)
  }

  function Hyperdrive (nameOrKey, opts) {
    if (!nameOrKey) throw new Error('Must give a name or key in the constructor')

    opts = Object.assign({}, DEFAULT_DRIVE_OPTS, driveOpts, opts)

    let key = null

    try {
      key = DatEncoding.decode(nameOrKey)
      // Normalize keys to be hex strings of the key instead of dat URLs
      nameOrKey = key.toString('hex')
    } catch (e) {
      // Probably isn't a `dat://` URL, so it must be a name
    }

    if (drives.has(nameOrKey)) return drives.get(nameOrKey)

    opts.namespace = nameOrKey

    const { persist } = opts

    let driveStorage = corestore
    if (!persist) {
      driveStorage = RAM
    } else if (opts.storage) {
      driveStorage = opts.storage(key)
    } else {
      driveStorage = corestore
    }

    const drive = makeHyperdrive(driveStorage, key, opts)

    drives.set(nameOrKey, drive)
    if (!key) {
      drive.ready(() => {
        const key = drive.key
        const stringKey = key.toString('hex')
        drives.set(stringKey, drive)
      })
    }

    drive.ready(() => {
      swarm.seed(drive.discoveryKey)
    })

    drive.once('close', () => {
      swarm.unseed(drive.discoveryKey)

      const key = drive.key
      const stringKey = key.toString('hex')

      drives.delete(stringKey)
      drives.delete(nameOrKey)
    })

    return drive
  }

  function Hypercore (nameOrKey, opts) {
    if (!nameOrKey) throw new Error('Must give a name or key in the constructor')

    opts = Object.assign({}, DEFAULT_CORE_OPTS, driveOpts, opts)

    let key = null

    try {
      key = DatEncoding.decode(nameOrKey)
      // Normalize keys to be hex strings of the key instead of dat URLs
      nameOrKey = key.toString('hex')
    } catch (e) {
      // Probably isn't a `dat://` URL, so it must be a name
    }

    if (cores.has(nameOrKey)) return cores.get(nameOrKey)

    const { persist } = opts
    let coreStorage = null

    if (!persist) {
      coreStorage = RAM
    } else if (opts.storage) {
      coreStorage = opts.storage(key)
    }

    let core = null

    // If sotrage was passed in the opts, use it. Else use the corestore
    if (coreStorage) {
      // We only want to generate keys if we have a custom storage
      // Else the corestore does fancy key storage for us
      if (!key) {
        const { publicKey, secretKey } = crypto.keyPair()
        key = publicKey
        opts.secretKey = secretKey
      }
      core = makeHypercore(coreStorage, key, opts)
    } else {
      if (key) {
        // If a dat key was provided, get it from the corestore
        core = corestore.get({ key, ...opts })
      } else {
        // If no dat key was provided, but a name was given, use it as a namespace
        core = corestore.namespace(nameOrKey).default(opts)
      }
    }

    cores.set(nameOrKey, core)
    if (!key) {
      core.ready(() => {
        const key = core.key
        const stringKey = key.toString('hex')
        cores.set(stringKey, core)
      })
    }

    core.ready(() => {
      swarm.seed(core.discoveryKey)
    })

    core.once('close', () => {
      const key = core.key
      const stringKey = key.toString('hex')

      swarm.unseed(core.discoveryKey)
      cores.delete(stringKey)
      cores.delete(nameOrKey)
    })

    return core
  }
}