How to use pull-stream - 10 common examples

handleRequest(protocol, conn) {
        pull(
            /* prettier-ignore */
            conn,
            lp.decode(),
            pull.map(Message.decode),
            pull.drain(message => this.processMessage(conn, message))
        )
    }

return cb(null, resolveItem(null, item.object, item, options.offset, options.length))
      }

      const cid = new CID(item.multihash)

      dag.get(cid, (err, node) => {
        if (err) {
          return cb(err)
        }

        // const name = item.fromPathRest ? item.name : item.path
        cb(null, resolveItem(cid, node.value, item, options.offset, options.length))
      })
    }),
    pull.flatten(),
    pull.filter(Boolean),
    pull.filter((node) => node.depth <= options.maxDepth)
  )

  function resolveItem (cid, node, item, offset, length) {
    return resolve(cid, node, item.name, item.path, item.pathRest, item.size, dag, item.parent || parent, item.depth, offset, length)
  }

  function resolve (cid, node, name, path, pathRest, size, dag, parentNode, depth, offset, length) {
    let type

    try {
      type = typeOf(node)
    } catch (error) {
      return pull.error(error)
    }

const query = [{
      $filter: {
        value: {
          author: server.id,
          timestamp: { $gt: 0 }, // needed for how I set up /query page
          content: { type: 'dark-crystal/root' }
        }
      }
    }]

    const _opts = Object.assign({}, { query }, opts)
    // NOTE - this could benefit from a deeper merge?

    return pull(
      next(server.query.read, _opts),
      pull.filter(isRoot)
    )
  }
}

function migrate () {
          // actual upgrade
          pull(
            db.createLogStream({gt: since}),
            paramap(function (data, cb) {
              prog.current += 1
              flumedb.rawAppend(data, cb)
            }, 32),
            pull.drain(null, ready)
          )
        }
      }

test('write a file', function (t) {
  var lines = ['a\n', 'b\n', 'c\n'].map(Buffer)
  var file = '/tmp/test-pfs-write'
  pull(
    pull.values(lines),
    pfs.write(file, function (err) {
      if(err) throw err
      fs.readFile(file, 'utf-8', function (err, data) {
        if(err) throw err
        t.equal(data, lines.join(''))
        t.end()
      })
    })
  )
})

function log (name) {
  return pull.through(function (data) {
    console.log(name, data)
  })
}

tape('add, size', function (t) {

  pull(
    pull.values(random1),
    blobs.add(function (err, hash) {
      if(err) throw err
      t.equal(hash, hash1)
      blobs.size(hash, function (_, size) {
        t.equal(size, 100*1024)
        t.end()
      })
    })
  )
})

function hasher (ary) {
    var hasher = util.createHash(alg, true)
    pull(pull.values(ary), hasher, pull.drain())
    return util.encode(hasher.digest, alg)
  }

function all(stream, cb) {
  pull(stream, pull.collect(cb))
}

function all (stream, cb) {
  pull(stream, pull.collect(cb))
}