How to use ssb-ref - 10 common examples

// return function that'll construct the right view when called
    return function () {
      var el = require('./feeds')(sbot, screen, filter)
      el.setLabel(label+': '+userId)
      return el
    }
  }

  return graphs[graph]()
}

if (!module.parent) {
  var argv = require('minimist')(process.argv.slice(2))
  var graph  = argv._[0]
  var userId = argv._[1]
  if (['follows', 'followers', 'flags', 'flaggers'].indexOf(graph) === -1 || !require('ssb-ref').isFeed(userId)) {
    console.error('Usage: graph.js [follows|followers|flags|flaggers] {feedid}')
    process.exit(1)
  }
  require('./lib/app')(module.exports.bind(null, graph, userId))
}

createWorking: function (opts, cb) {
      if (!opts || !opts.name || !bundleNameRegex.test(opts.name))
        return cb(error('Invalid name', { invalidName: true }))
      if (!opts.desc || typeof opts.desc != 'string')
        return cb(error('Invalid desc', { invalidDesc: true }))
      if (!opts.dirpath || typeof opts.dirpath != 'string')
        return cb(error('Invalid directory path', { invalidDirpath: true }))
      if (opts.root && !ref.isMsgId(opts.root))
        return cb(error('Invalid root hash', { invalidRoot: true }))
      if (opts.branch && !ref.isMsgId(opts.branch))
        return cb(error('Invalid branch hash', { invalidBranch: true }))

      // add working bundle to db
      var bundle = {
        id: makeWorkingid(),
        name: normalizeName(opts.name),
        desc: opts.desc,
        root: opts.root,
        branch: opts.branch,
        dirpath: opts.dirpath
      }
      var done = multicb()
      workingDB.put(bundle.id, bundle, done())
      bundlesDB.put([normalizeName(bundle.name), bundle.id], 1, done())
      if (bundle.root)
        bundlesDB.put([bundle.root, bundle.id], 1, done())

var modern = false
        if(ref.isInvite(invite)) { //legacy ivite
          if(ref.isLegacyInvite(invite)) {
            var parts = invite.split('~')
            opts = ref.parseAddress(parts[0])//.split(':')
            //convert legacy code to multiserver invite code.
            var protocol = 'net:'
            if (opts.host.endsWith(".onion"))
              protocol = 'onion:'
            invite = protocol+opts.host+':'+opts.port+'~shs:'+opts.key.slice(1, -8)+':'+parts[1]
          }
          else
            modern = true
        }

        opts = ref.parseAddress(ref.parseInvite(invite).remote)
        function connect (cb) {
          ssbClient(null, {
            caps: config.caps,
            remote: invite,
            manifest: {invite: {use: 'async'}, getAddress: 'async'}
          }, cb)
        }

        // retry 3 times, with timeouts.
        // This is an UGLY hack to get the test/invite.js to pass
        // it's a race condition, I think because the server isn't ready
        // when it connects?

        function retry (fn, cb) {
          var n = 0
          ;(function next () {

}, function (err) {
          // emit the invite code: our server address, plus the key-seed
          if(err) cb(err)
          else if(opts.modern) {
            var ws_addr = getInviteAddress().split(';').sort(function (a, b) {
               return +/^ws/.test(b) - +/^ws/.test(a)
            }).shift()


            if(!/^ws/.test(ws_addr)) throw new Error('not a ws address:'+ws_addr)
            cb(null, ws_addr+':'+seed.toString('base64'))
          }
          else {
            addr = ref.parseAddress(addr)
            cb(null, [opts.external ? opts.external : addr.host, addr.port, addr.key].join(':') + '~' + seed.toString('base64'))
          }
        })
      }, 'number|object', 'string?'),

connect: valid.async(function (addr, cb) {
        if(ref.isFeed(addr))
          addr = gossip.get(addr)
        server.emit('log:info', ['SBOT', stringify(addr), 'CONNECTING'])
        if(!ref.isAddress(addr.address))
          addr = ma.decode(addr)
        if (!addr || typeof addr != 'object')
          return cb(new Error('first param must be an address'))

        if(!addr.address)
          if(!addr.key) return cb(new Error('address must have ed25519 key'))
        // add peer to the table, incase it isn't already.
        gossip.add(addr, 'manual')
        var p = gossip.get(addr)
        if(!p) return cb()

        p.stateChange = Date.now()
        p.state = 'connecting'
        server.connect(p.address, function (err, rpc) {
          if (err) {
            p.error = err.stack

accept: valid.async(function (invite, cb) {
        // remove surrounding quotes, if found
        if (invite.charAt(0) === '"' && invite.charAt(invite.length - 1) === '"')
          invite = invite.slice(1, -1)
        var opts
        // connect to the address in the invite code
        // using a keypair generated from the key-seed in the invite code
        var modern = false
        if(ref.isInvite(invite)) { //legacy ivite
          if(ref.isLegacyInvite(invite)) {
            var parts = invite.split('~')
            opts = ref.parseAddress(parts[0])//.split(':')
            //convert legacy code to multiserver invite code.
            var protocol = 'net:'
            if (opts.host.endsWith(".onion"))
              protocol = 'onion:'
            invite = protocol+opts.host+':'+opts.port+'~shs:'+opts.key.slice(1, -8)+':'+parts[1]
          }
          else
            modern = true
        }

        opts = ref.parseAddress(ref.parseInvite(invite).remote)
        function connect (cb) {
          ssbClient(null, {

accept: valid.async(function (invite, cb) {
        // remove surrounding quotes, if found
        if (invite.charAt(0) === '"' && invite.charAt(invite.length - 1) === '"')
          invite = invite.slice(1, -1)
        var opts
        // connect to the address in the invite code
        // using a keypair generated from the key-seed in the invite code
        var modern = false
        if(ref.isInvite(invite)) { //legacy ivite
          if(ref.isLegacyInvite(invite)) {
            var parts = invite.split('~')
            opts = ref.parseAddress(parts[0])//.split(':')
            //convert legacy code to multiserver invite code.
            var protocol = 'net:'
            if (opts.host.endsWith(".onion"))
              protocol = 'onion:'
            invite = protocol+opts.host+':'+opts.port+'~shs:'+opts.key.slice(1, -8)+':'+parts[1]
          }
          else
            modern = true
        }

        opts = ref.parseAddress(ref.parseInvite(invite).remote)
        function connect (cb) {
          ssbClient(null, {
            caps: config.caps,

pull.drain(function (contacts) {
          if(!contacts) return

          if (isFeed(contacts.from) && isFeed(contacts.to)) { // live data
            handleBlockUnlock(contacts.from, contacts.to, contacts.value)
          } else { // initial data
            for (var from in contacts) {
              var relations = contacts[from]
              for (var to in relations)
                handleBlockUnlock(from, to, relations[to])
            }
          }
        })
      )

isBlockedOpts: function (v, n) {
    var err = this.get('object')(v, n)
    if (err)
      return err

    // .source
    if (v.source && !ref.isFeed(v.source))
      return AttrType(n, 'source', 'feedId')

    // .dest
    if (v.dest && !ref.isFeed(v.dest))
      return AttrType(n, 'dest', 'feedId')
  },

//allow content to be string. (i.e. for encrypted messages)
    //or object with type string
    if(!v.content)
      return MissingAttr(n, 'content', 'object|string')
    else if(typeof v.content === 'string')
      ; //check if it's base64?
    else if('object' === typeof v.content) {
      if(!v.content.type || typeof v.content.type != 'string')
      return MissingAttr(n, 'content.type', 'string')
    }
    else
      return MissingAttr(n, 'content', 'object|string')

    // .author
    if (!ref.isFeed(v.author))
      return MissingAttr(n, 'author', 'feedId')

    // .sequence
    if (typeof v.sequence != 'number')
      return MissingAttr(n, 'sequence', 'number')

    // .previous
    if (v.sequence > 1 && !ref.isMsg(v.previous))
      return MissingAttr(n, 'previous', 'msgId')
    else if(v.sequence == 1 && v.previous != null)
      return MissingAttr(n, 'previous', 'null')

    // .timestamp
    if (typeof v.timestamp != 'number')
      return MissingAttr(n, 'timestamp', 'number')