Adapt listMembers to exclusion and test it

index.js

@@ -33,7 +33,7 @@ const buildGroupId = require('./lib/build-group-id')
 const addTangles = require('./lib/tangles/add-tangles')
 const publishAndPrune = require('./lib/prune-publish')
 const MetaFeedHelpers = require('./lib/meta-feed-helpers')
-// const Epochs = require('./lib/epochs')
+const Epochs = require('./lib/epochs')
 
 module.exports = {
   name: 'tribes2',
@@ -58,7 +58,7 @@ module.exports = {
       findOrCreateGroupWithoutMembers,
       getRootFeedIdFromMsgId,
     } = MetaFeedHelpers(ssb)
-    // const { getEpochs } = Epochs(ssb)
+    const { getPickedEpoch, getMembers } = Epochs(ssb)
 
     function create(opts = {}, cb) {
       if (cb === undefined) return promisify(create)(opts)
@@ -313,31 +313,16 @@ module.exports = {
       return pull(
         pull.values([0]),
         pull.asyncMap((n, cb) => {
-          get(groupId, (err, group) => {
+          getPickedEpoch(groupId, (err, pickedEpoch) => {
             // prettier-ignore
-            if (err) return cb(clarify(err, 'Failed to get group info when listing members'))
+            if (err) return cb(clarify(err, 'todo'))
 
-            if (group.excluded) {
-              return cb(
-                new Error("We're excluded from this group, can't list members")
-              )
-            } else {
-              const source = pull(
-                ssb.db.query(
-                  where(and(isDecrypted('box2'), type('group/add-member'))),
-                  opts.live ? live({ old: true }) : null,
-                  toPullStream()
-                ),
-                pull.map((msg) => lodashGet(msg, 'value.content.recps', [])),
-                pull.filter(
-                  (recps) => recps.length > 1 && recps[0] === groupId
-                ),
-                pull.map((recps) => recps.slice(1)),
-                pull.flatten(),
-                pull.unique()
-              )
-              return cb(null, source)
-            }
+            getMembers(pickedEpoch.id, (err, pickedEpochMembers) => {
+              // prettier-ignore
+              if (err) return cb(clarify(err, 'todo'))
+
+              cb(null, pickedEpochMembers.members)
+            })
           })
         }),
         pull.flatten()

lib/epochs.js

@@ -17,8 +17,8 @@ const {
       initEpoch: isInitEpoch,
       addMember: isAddMember,
       exclude: isExclude,
-    }
-  }
+    },
+  },
 } = require('private-group-spec')
 
 const getTangleUpdates = require('./tangles/get-tangle-updates')
@@ -27,7 +27,7 @@ const msgPattern = toPattern(new Butt64('ssb:message/[a-zA-Z0-9-]+/', null, 32))
 const feedPattern = toPattern(new Butt64('ssb:feed/[a-zA-Z0-9-]+/', null, 32))
 const secretPattern = toPattern(isCanonicalBase64(null, null, 32))
 
-function toPattern (regexp) {
+function toPattern(regexp) {
   return regexp.toString().replace(/^\//, '').replace(/\/$/, '')
 }
 
@@ -39,69 +39,97 @@ const strategy = OverwriteFields({
     required: ['author', 'epochKey'],
     author: {
       type: 'string',
-      pattern: feedPattern
+      pattern: feedPattern,
     },
     epochKey: {
       type: 'string',
-      pattern: secretPattern
-    }
-  }
+      pattern: secretPattern,
+    },
+  },
 })
-strategy.mapToPure = T => T || strategy.identity() // function @tangle/reduce needs
+strategy.mapToPure = (T) => T || strategy.identity() // function @tangle/reduce needs
 
-module.exports = function Epochs (ssb) {
-  function getEpochs (groupId, cb) {
+module.exports = function Epochs(ssb) {
+  function getEpochs(groupId, cb) {
     if (cb === undefined) return p(getEpochs)(groupId)
 
     reduceEpochs(ssb, groupId, (err, reduce) => {
       if (err) return cb(clarify(err, 'Failed to resolve epoch @tangle/reduce'))
 
-      const epochs = reduce.graph.connectedNodes
-        .map(node => {
-          return {
-            id: node.key,
-            previous: node.previous,
-            author: node.data[node.key].author,
-            epochKey: Buffer.from(node.data[node.key].epochKey, 'base64')
-          }
-        })
+      const epochs = reduce.graph.connectedNodes.map((node) => {
+        return {
+          id: node.key,
+          previous: node.previous,
+          author: node.data[node.key].author,
+          epochKey: Buffer.from(node.data[node.key].epochKey, 'base64'),
+        }
+      })
 
       cb(null, epochs)
     })
   }
 
-  function getMembers (epochRoot, cb) {
+  /**
+   * Get the epoch matching the currently picked write key for the group.
+   */
+  function getPickedEpoch(groupId, cb) {
+    if (cb === undefined) return p(getPickedEpoch)(groupId)
+
+    ssb.box2.getGroupInfo(groupId, (err, info) => {
+      // prettier-ignore
+      if (err) return cb(clarify(err, 'Failed to get group info for ' + groupId))
+
+      // prettier-ignore
+      if (info.excluded) return cb(new Error("Can't get picked epoch for group we're excluded from"))
+
+      getEpochs(groupId, (err, epochs) => {
+        // prettier-ignore
+        if (err) return cb(clarify(err, 'todo'))
+
+        cb(
+          null,
+          epochs.find((epoch) => epoch.epochKey.equals(info.writeKey.key))
+        )
+      })
+    })
+  }
+
+  function getMembers(epochRoot, cb) {
     if (cb === undefined) return p(getMembers)(epochRoot)
 
     getEpochMembers(ssb, epochRoot, cb)
   }
 
   return {
     getEpochs,
+    getPickedEpoch,
     getMembers,
   }
 }
 
-function reduceEpochs (ssb, groupId, cb) {
+function reduceEpochs(ssb, groupId, cb) {
   ssb.box2.getGroupInfo(groupId, (err, info) => {
     if (err) return cb(clarify(err, 'Failed to get group info for ' + groupId))
 
     ssb.db.get(info.root, (err, rootVal) => {
+      // prettier-ignore
       if (err) return cb(clarify(err, 'Failed to load group root with id ' + info.root))
-      if (!isInitRoot(rootVal)) return cb(clarify(new Error(isInitRoot.string), 'Malformed group/init root message'))
+
+      if (!isInitRoot(rootVal))
+        // prettier-ignore
+        return cb(clarify(new Error(isInitRoot.string), 'Malformed group/init root message'))
 
       const root = { key: info.root, value: rootVal }
 
       getTangleUpdates(ssb, 'epoch', info.root, (err, updates) => {
+        // prettier-ignore
         if (err) return cb(clarify(err, 'Failed to updates of group epoch tangle'))
 
         pull(
-          pull.values([
-            root,
-            ...updates.filter(isInitEpoch)
-          ]),
+          pull.values([root, ...updates.filter(isInitEpoch)]),
           pull.asyncMap((msg, cb) => {
             ssb.metafeeds.findRootFeedId(msg.value.author, (err, feedId) => {
+              // prettier-ignore
               if (err) return cb(clarify(err, 'Failed find root feed id of ' + msg.value.author))
 
               const key = toMsgURI(msg.key)
@@ -111,13 +139,14 @@ function reduceEpochs (ssb, groupId, cb) {
                 data: {
                   [key]: {
                     author: feedId,
-                    epochKey: msg.value.content.groupKey
-                  }
-                }
+                    epochKey: msg.value.content.groupKey,
+                  },
+                },
               })
             })
           }),
           pull.collect((err, nodes) => {
+            // prettier-ignore
             if (err) return cb(clarify(err, 'Failure collecting epoch messages'))
 
             const reduce = new Reduce(strategy, { nodes })
@@ -131,26 +160,26 @@ function reduceEpochs (ssb, groupId, cb) {
     })
   })
 }
-function toMsgURI (id) {
+function toMsgURI(id) {
   return id.startsWith('%') ? fromMessageSigil(id) : id
 }
 
-function getEpochMembers (ssb, epochRoot, cb) {
+function getEpochMembers(ssb, epochRoot, cb) {
   const members = new Set()
   const toExclude = new Set()
 
   pull(
     getTangleUpdates.stream(ssb, 'members', epochRoot),
-    pull.filter(msg => isAddMember(msg) || isExclude(msg)),
+    pull.filter((msg) => isAddMember(msg) || isExclude(msg)),
     pull.drain(
-      msg => {
+      (msg) => {
         const { type, recps, excludes } = msg.value.content
         if (type === 'group/add-member')
-          recps.slice(1).forEach(feedId => members.add(feedId))
-        else
-          excludes.forEach(feedId => toExclude.add(feedId))
+          recps.slice(1).forEach((feedId) => members.add(feedId))
+        else excludes.forEach((feedId) => toExclude.add(feedId))
       },
-      err => {
+      (err) => {
+        // prettier-ignore
         if (err) return cb(clarify(err, 'Failed to resolve epoch membership'))
         cb(null, {
           members: [...members],

test/exclude-members.test.js

@@ -290,7 +290,7 @@ test('Verify that you actually get excluded from a group', async (t) => {
   await p(bob.close)(true)
 })
 
-test("If you're not the excluder nor the excludee then you should still be in the group and have access to the new epoch", async (t) => {
+test.only("If you're not the excluder nor the excludee then you should still be in the group and have access to the new epoch", async (t) => {
   // alice creates the group. adds bob and carol. removes bob.
   // bob gets added and is removed
   // carol stays in the group
@@ -321,7 +321,7 @@ test("If you're not the excluder nor the excludee then you should still be in th
   await carol.tribes2.start()
   t.pass('tribes2 started for everyone')
 
-  await p(alice.metafeeds.findOrCreate)()
+  const aliceRoot = await p(alice.metafeeds.findOrCreate)()
   const bobRoot = await p(bob.metafeeds.findOrCreate)()
   const carolRoot = await p(carol.metafeeds.findOrCreate)()
 
@@ -413,6 +413,26 @@ test("If you're not the excluder nor the excludee then you should still be in th
     'Carol has a feed for the new key'
   )
 
+  const aliceMembers = await pull(
+    alice.tribes2.listMembers(groupId),
+    pull.collectAsPromise()
+  )
+  t.deepEquals(
+    aliceMembers.sort(),
+    [aliceRoot.id, carolRoot.id].sort(),
+    'alice gets the correct members list'
+  )
+
+  const carolMembers = await pull(
+    carol.tribes2.listMembers(groupId),
+    pull.collectAsPromise()
+  )
+  t.deepEquals(
+    carolMembers.sort(),
+    [aliceRoot.id, carolRoot.id].sort(),
+    'carol gets the correct members list'
+  )
+
   await p(alice.close)(true)
   await p(bob.close)(true)
   await p(carol.close)(true)