Adapt listMembers to exclusion and test it

.eslintrc.js

@@ -13,7 +13,7 @@ module.exports = {
     SharedArrayBuffer: 'readonly',
   },
   parserOptions: {
-    ecmaVersion: 2020,
+    ecmaVersion: 2021,
     sourceType: 'module',
   },
   rules: {

index.js

@@ -34,8 +34,8 @@ 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 { groupRecp } = require('./lib/operators')
-// const Epochs = require('./lib/epochs')
 
 module.exports = {
   name: 'tribes2',
@@ -60,7 +60,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)
@@ -319,35 +319,21 @@ module.exports = {
     }
 
     function listMembers(groupId, opts = {}) {
-      const deferedSource = pullDefer.source()
+      const deferredSource = pullDefer.source()
 
-      get(groupId, (err, group) => {
-        // prettier-ignore
-        if (err) return deferedSource.abort(clarify(err, 'Failed to get group info when listing members'))
+      getPickedEpoch(groupId, (err, pickedEpoch) => {
         // prettier-ignore
-        if (group.excluded) return deferedSource.abort( new Error("We're excluded from this group, can't list members"))
+        if (err) return deferredSource.abort(clarify(err, 'todo'))
 
-        const source = pull(
-          ssb.db.query(
-            where(
-              and(
-                isDecrypted('box2'),
-                type('group/add-member'),
-                groupRecp(groupId)
-              )
-            ),
-            opts.live ? live({ old: true }) : null,
-            toPullStream()
-          ),
-          pull.map((msg) => msg.value.content.recps.slice(1)),
-          pull.flatten(),
-          pull.unique()
-        )
+        getMembers(pickedEpoch.id, (err, pickedEpochMembers) => {
+          // prettier-ignore
+          if (err) return deferredSource.abort(clarify(err, 'todo'))
 
-        deferedSource.resolve(source)
+          deferredSource.resolve(pull.values(pickedEpochMembers.members))
+        })
       })
 
-      return deferedSource
+      return deferredSource
     }
 
     function listInvites() {
@@ -528,9 +514,7 @@ module.exports = {
           paraMap((msg, cb) => {
             pull(
               ssb.box2.listGroupIds(),
-              pull.filter((groupId) =>
-                groupId === msg.value.content.recps[0]
-              ),
+              pull.filter((groupId) => groupId === msg.value.content.recps[0]),
               pull.take(1),
               pull.collect((err, groupIds) => {
                 // prettier-ignore

lib/epochs.js

@@ -101,6 +101,36 @@ module.exports = function Epochs(ssb) {
       })
     },
 
+    /**
+     * Get the epoch matching the currently picked write key for the group.
+     */
+    getPickedEpoch(groupId, opts) {
+      return pull(
+        opts?.live
+          ? ssb.box2.getGroupInfoUpdates(groupId)
+          : pull(ssb.box2.getGroupInfoUpdates(groupId), pull.take(1))
+        //pull.compareToTheLastOne?isTheWriteKeyDifferent?
+      )
+
+      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))
+          )
+        })
+      })
+    },
+
     getMembers(epochRootId, cb) {
       if (cb === undefined) return p(this.getMembers)(epochRootId)
 
@@ -111,8 +141,8 @@ module.exports = function Epochs(ssb) {
       if (cb === undefined) return p(this.getMissingMembers)(groupId)
 
       reduceEpochs(ssb, groupId, allGetters, (err, reduce) => {
-        if (err)
-          return cb(clarify(err, 'Failed to resolve epoch @tangle/reduce'))
+        // prettier-ignore
+        if (err) return cb(clarify(err, 'Failed to resolve epoch @tangle/reduce'))
 
         if (reduce.graph.connectedNodes.length === 1) return cb(null, [])
         // INFO if there is only one connectedNode, there is only a
@@ -160,7 +190,6 @@ module.exports = function Epochs(ssb) {
         throw Error('tieBreak requires an Array of epochs')
 
       const keys = epochs.map((epoch) => epoch.epochKey.toString('hex')).sort()
-      console.log(keys)
 
       const winningKey = Buffer.from(keys[0], 'hex')
 
@@ -188,28 +217,24 @@ function reduceEpochs(ssb, groupId, getters = {}, cb) {
   //   and nodes under `resolve.graph` (which is a @tangle/graph object)
 
   ssb.box2.getGroupInfo(groupId, (err, info) => {
+    // prettier-ignore
     if (err) return cb(clarify(err, 'Failed to get group info for ' + groupId))
 
     // Fetch the tangle root
     ssb.db.get(info.root, (err, rootVal) => {
-      if (err)
-        return cb(
-          clarify(err, 'Failed to load group root with id ' + info.root)
-        )
+      // 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'
-          )
-        )
+        // prettier-ignore
+        return cb(clarify(new Error(isInitRoot.string), 'Malformed group/init root message'))
 
       const root = { key: info.root, value: rootVal }
 
       // Fetch the tangle updates
       getTangleUpdates(ssb, 'epoch', info.root, (err, updates) => {
-        if (err)
-          return cb(clarify(err, 'Failed to updates of group epoch tangle'))
+        // prettier-ignore
+        if (err) return cb(clarify(err, 'Failed to updates of group epoch tangle'))
 
         // Take each root/update and build an epoch "node" for our tangle
         pull(
@@ -230,22 +255,24 @@ function reduceEpochs(ssb, groupId, getters = {}, cb) {
               pull.values(Object.entries(getters)),
               pull.asyncMap(([fieldName, getter], cb) => {
                 getter(msg, (err, fieldData) => {
-                  if (err)
-                    return cb(clarify(err, 'Failed to get epoch ' + fieldName))
+                  // prettier-ignore
+                  if (err) return cb(clarify(err, 'Failed to get epoch ' + fieldName))
+
                   epochData[fieldName] = fieldData
                   cb(null)
                 })
               }),
               pull.collect((err) => {
+                // prettier-ignore
                 if (err) return cb(clarify(err, 'Failed to collect epoch data'))
 
                 cb(null, node)
               })
             )
           }),
           pull.collect((err, nodes) => {
-            if (err)
-              return cb(clarify(err, 'Failure collecting epoch messages'))
+            // prettier-ignore
+            if (err) return cb(clarify(err, 'Failure collecting epoch messages'))
 
             // Finally reduce all of these epoch nodes with a tangle
             const reduce = new Reduce(strategy, { nodes })
@@ -276,7 +303,9 @@ function getMembers(ssb, epochRootId, cb) {
         else excludes.forEach((feedId) => toExclude.add(feedId))
       },
       (err) => {
+        // prettier-ignore
         if (err) return cb(clarify(err, 'Failed to resolve epoch membership'))
+
         cb(null, {
           added: [...added],
           toExclude: [...toExclude],

lib/tangles/get-tangle-data.js

@@ -27,6 +27,7 @@ function getTangleRoot(server, tangle, groupId, cb) {
       return cb(new Error(`get-tangle: unknown groupId ${groupId}`))
     }
 
+    // TODO: use getPickedEpoch?
     if (tangle === 'members') {
       // we find the id of the init msg for the current epoch
       pull(

package.json

@@ -49,7 +49,7 @@
     "pull-stream": "^3.7.0",
     "set.prototype.difference": "^1.0.2",
     "ssb-bfe": "^3.7.0",
-    "ssb-box2": "^6.1.0",
+    "ssb-box2": "ssbc/ssb-box2#getgroupinfoupdates",
     "ssb-crut": "^4.6.2",
     "ssb-db2": "^6.3.3",
     "ssb-meta-feeds": "^0.39.0",

test/exclude-members.test.js

@@ -271,18 +271,6 @@ test('Verify that you actually get excluded from a group', async (t) => {
   const invites = await pull(bob.tribes2.listInvites(), pull.collectAsPromise())
   t.deepEquals(invites, [], 'Bob has no invites')
 
-  await pull(bob.tribes2.listMembers(groupId), pull.collectAsPromise())
-    .then(() =>
-      t.fail(
-        "Bob didn't get an error when trying to list members of the group he's excluded from"
-      )
-    )
-    .catch(() =>
-      t.pass(
-        "Bob gets an error when trying to list members of the group he's excluded from"
-      )
-    )
-
   await Promise.all([p(alice.close)(true), p(bob.close)(true)])
 })
 

test/list-members.test.js

@@ -138,3 +138,110 @@ test('live list members', async (t) => {
 
   await Promise.all([p(alice.close)(true), p(bob.close)(true)])
 })
+
+test('listMembers works with exclusion', async (t) => {
+  const alice = Testbot({
+    keys: ssbKeys.generate(null, 'alice'),
+    mfSeed: Buffer.from(
+      '000000000000000000000000000000000000000000000000000000000000a1ce',
+      'hex'
+    ),
+  })
+  const bob = Testbot({
+    keys: ssbKeys.generate(null, 'bob'),
+    mfSeed: Buffer.from(
+      '0000000000000000000000000000000000000000000000000000000000000b0b',
+      'hex'
+    ),
+  })
+  const carol = Testbot({
+    keys: ssbKeys.generate(null, 'carol'),
+    mfSeed: Buffer.from(
+      '00000000000000000000000000000000000000000000000000000000000ca201',
+      'hex'
+    ),
+  })
+
+  await Promise.all([
+    alice.tribes2.start(),
+    bob.tribes2.start(),
+    carol.tribes2.start(),
+  ]).then(() => t.pass('tribes2 started for everyone'))
+
+  const [aliceRoot, bobRoot, carolRoot] = await Promise.all([
+    p(alice.metafeeds.findOrCreate)(),
+    p(bob.metafeeds.findOrCreate)(),
+    p(carol.metafeeds.findOrCreate)(),
+  ])
+
+  await Promise.all([
+    replicate(alice, bob),
+    replicate(alice, carol),
+    replicate(bob, carol),
+  ]).then(() => t.pass('everyone replicates their trees'))
+
+  const { id: groupId } = await alice.tribes2
+    .create()
+    .catch((err) => t.error(err, 'alice failed to create group'))
+
+  await replicate(alice, carol)
+
+  await alice.tribes2
+    .addMembers(groupId, [bobRoot.id, carolRoot.id])
+    .catch((err) => t.error(err, 'add bob fail'))
+
+  await replicate(alice, carol)
+
+  await bob.tribes2.acceptInvite(groupId)
+  await carol.tribes2.acceptInvite(groupId)
+
+  await replicate(alice, bob)
+  await replicate(alice, carol)
+
+  await alice.tribes2
+    .excludeMembers(groupId, [bobRoot.id])
+    .then((res) => {
+      t.pass('alice excluded bob')
+      return res
+    })
+    .catch((err) => t.error(err, 'remove member fail'))
+
+  await replicate(alice, bob)
+  await replicate(alice, carol)
+
+  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 pull(bob.tribes2.listMembers(groupId), pull.collectAsPromise())
+    .then(() =>
+      t.fail(
+        "Bob didn't get an error when trying to list members of the group he's excluded from"
+      )
+    )
+    .catch(() =>
+      t.pass(
+        "Bob gets an error when trying to list members of the group he's excluded from"
+      )
+    )
+
+  await p(alice.close)(true)
+  await p(bob.close)(true)
+  await p(carol.close)(true)
+})