Basic member exclusion flow

index.js

@@ -21,6 +21,7 @@ const {
   },
   keySchemes,
 } = require('private-group-spec')
+const { SecretKey } = require('ssb-private-group-keys')
 const { fromMessageSigil, isBendyButtV1FeedSSBURI } = require('ssb-uri2')
 const buildGroupId = require('./lib/build-group-id')
 const AddTangles = require('./lib/add-tangles')
@@ -43,14 +44,14 @@ module.exports = {
       secretKeyFromString,
       findOrCreateAdditionsFeed,
       findOrCreateGroupFeed,
-      findOrCreateGroupWithoutMembers,
+      findOrCreateEpochWithoutMembers,
       getRootFeedIdFromMsgId,
     } = MetaFeedHelpers(ssb)
 
     function create(opts = {}, cb) {
       if (cb === undefined) return promisify(create)(opts)
 
-      findOrCreateGroupWithoutMembers((err, group) => {
+      findOrCreateEpochWithoutMembers((err, group) => {
         // prettier-ignore
         if (err) return cb(clarify(err, 'Failed to create group init message when creating a group'))
 
@@ -159,22 +160,102 @@ module.exports = {
       })
     }
 
-    function publish(content, cb) {
-      if (cb === undefined) return promisify(publish)(content)
+    function excludeMembers(groupId, feedIds, opts = {}, cb) {
+      if (cb === undefined)
+        return promisify(excludeMembers)(groupId, feedIds, opts)
+
+      ssb.metafeeds.findOrCreate(function gotRoot(err, myRoot) {
+        if (err) return cb(err)
+
+        const excludeContent = {
+          type: 'group/exclude',
+          excludes: feedIds,
+          recps: [groupId],
+        }
+        const excludeOpts = { tangles: ['group', 'members'], spec: () => true }
+        publish(excludeContent, excludeOpts, (err, exclusionMsg) => {
+          // prettier-ignore
+          if (err) return cb(clarify(err, 'Failed to publish exclude msg'))
+
+          pull(
+            listMembers(groupId),
+            pull.collect((err, beforeMembers) => {
+              if (err) return cb(err)
+
+              const remainingMembers = beforeMembers.filter(
+                (member) => !feedIds.includes(member)
+              )
+              const newGroupKey = new SecretKey()
+              const addInfo = { key: newGroupKey.toBuffer() }
+
+              ssb.box2.addGroupInfo(groupId, addInfo, (err) => {
+                if (err) return cb(err)
+
+                const newKey = {
+                  key: newGroupKey.toBuffer(),
+                  scheme: keySchemes.private_group,
+                }
+                ssb.box2.pickGroupWriteKey(groupId, newKey, (err) => {
+                  if (err) return cb(err)
+
+                  const newEpochContent = {
+                    type: 'group/init',
+                    version: 'v2',
+                    groupKey: newGroupKey.toString('base64'),
+                    tangles: {
+                      members: { root: null, previous: null },
+                    },
+                    recps: [groupId, myRoot.id],
+                  }
+                  const newTangleOpts = {
+                    tangles: ['group', 'epoch'],
+                    spec: () => true,
+                  }
+                  publish(newEpochContent, newTangleOpts, (err) => {
+                    if (err) return cb(err)
+
+                    const newKeyContent = {
+                      type: 'group/move-epoch',
+                      secret: newGroupKey.toString('base64'),
+                      exclusion: fromMessageSigil(exclusionMsg.key),
+                      recps: [groupId, ...remainingMembers],
+                    }
+                    // TODO: loop if many members
+                    // TODO: post this on old feed
+                    publish(newKeyContent, { spec: () => true }, (err) => {
+                      // prettier-ignore
+                      if (err) return cb(clarify(err, 'Failed to tell people about new epoch'))
+
+                      return cb()
+                    })
+                  })
+                })
+              })
+            })
+          )
+        })
+      })
+    }
+
+    function publish(content, opts, cb) {
+      if (cb === undefined) return promisify(publish)(content, opts)
 
       if (!content) return cb(new Error('Missing content'))
 
+      const isSpec = opts?.spec ?? isContent
+      const tangles = opts?.tangles ?? ['group']
+
       const recps = content.recps
       if (!recps || !Array.isArray(recps) || recps.length < 1) {
         return cb(new Error('Missing recps'))
       }
       const groupId = recps[0]
 
-      addTangles(content, ['group'], (err, content) => {
+      addTangles(content, tangles, (err, content) => {
         // prettier-ignore
         if (err) return cb(clarify(err, 'Failed to add group tangle when publishing to a group'))
 
-        if (!isContent(content)) return cb(new Error(isContent.errorsString))
+        if (!isSpec(content)) return cb(new Error(isSpec.errorsString))
 
         get(groupId, (err, { writeKey }) => {
           // prettier-ignore
@@ -314,6 +395,7 @@ module.exports = {
       get,
       list,
       addMembers,
+      excludeMembers,
       publish,
       listMembers,
       listInvites,

lib/add-tangles.js

@@ -11,6 +11,7 @@ module.exports = function AddTangles(server) {
   const getTangle = {
     group: GetTangle(server, 'group'),
     members: GetTangle(server, 'members'),
+    epoch: GetTangle(server, 'epoch'),
   }
 
   function addSomeTangles(content, tangles, cb) {

lib/meta-feed-helpers.js

@@ -171,7 +171,7 @@ module.exports = (ssb) => {
   /** more specifically: a group that has never had any members. i.e. either
    * 1. newly created but tribes2 crashed before we had time to add ourselves to it. in that case find and return it. if we can't find such a group then
    * 2. freshly create a new group, and return */
-  function findOrCreateGroupWithoutMembers(cb) {
+  function findOrCreateEpochWithoutMembers(cb) {
     ssb.metafeeds.findOrCreate(function gotRoot(err, myRoot) {
       // prettier-ignore
       if (err) return cb(clarify(err, 'Failed to find or create root feed when creating a group'))
@@ -260,7 +260,7 @@ module.exports = (ssb) => {
     findOrCreateFromSecret,
     findOrCreateGroupFeed,
     createGroupWithoutMembers,
-    findOrCreateGroupWithoutMembers,
+    findOrCreateEpochWithoutMembers,
     getRootFeedIdFromMsgId,
   }
 }

test/create.test.js

@@ -9,8 +9,8 @@ const { keySchemes } = require('private-group-spec')
 const Ref = require('ssb-ref')
 const { promisify: p } = require('util')
 const { where, type, toPromise } = require('ssb-db2/operators')
-const pull = require('pull-stream')
 const Testbot = require('./helpers/testbot')
+const countGroupFeeds = require('./helpers/count-group-feeds')
 
 test('create', async (t) => {
   const ssb = Testbot()
@@ -104,19 +104,6 @@ test('root message is encrypted', async (t) => {
   await p(alice.close)(true)
 })
 
-function countGroupFeeds(server, cb) {
-  pull(
-    server.metafeeds.branchStream({ old: true, live: false }),
-    pull.filter((branch) => branch.length === 4),
-    pull.map((branch) => branch[3]),
-    pull.filter((feed) => feed.recps),
-    pull.collect((err, feeds) => {
-      if (err) return cb(err)
-      return cb(null, feeds.length)
-    })
-  )
-}
-
 function createEmptyGroupFeed({ server, root }, cb) {
   const secret = new SecretKey()
   server.metafeeds.findOrCreate(

test/exclude-members.test.js

@@ -0,0 +1,163 @@
+// SPDX-FileCopyrightText: 2022 Andre 'Staltz' Medeiros <[email protected]>
+//
+// SPDX-License-Identifier: CC0-1.0
+
+const test = require('tape')
+const { promisify: p } = require('util')
+const ssbKeys = require('ssb-keys')
+const {
+  where,
+  and,
+  count,
+  isDecrypted,
+  type,
+  author,
+  toCallback,
+  toPullStream,
+  toPromise,
+} = require('ssb-db2/operators')
+const pull = require('pull-stream')
+const Testbot = require('./helpers/testbot')
+const replicate = require('./helpers/replicate')
+const countGroupFeeds = require('./helpers/count-group-feeds')
+
+test('add and remove a person, post on the new feed', async (t) => {
+  // feeds should look like
+  // first: initGroup->addAlice->addBob->excludeBob->reAddAlice
+  // second: initEpoch->post
+  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'
+    ),
+  })
+
+  await alice.tribes2.start()
+  await bob.tribes2.start()
+  t.pass('tribes2 started for both alice and bob')
+
+  await p(alice.metafeeds.findOrCreate)()
+  const bobRoot = await p(bob.metafeeds.findOrCreate)()
+
+  await replicate(alice, bob)
+  t.pass('alice and bob replicate their trees')
+
+  const {
+    id: groupId,
+    writeKey: writeKey1,
+    subfeed: { id: firstFeedId },
+  } = await alice.tribes2.create().catch((err) => {
+    console.error('alice failed to create group', err)
+    t.fail(err)
+  })
+  t.pass('alice created a group')
+
+  await alice.tribes2.addMembers(groupId, [bobRoot.id]).catch((err) => {
+    console.error('add member fail', err)
+    t.fail(err)
+  })
+  t.pass('alice added bob to the group')
+
+  t.equals(
+    await p(countGroupFeeds)(alice),
+    1,
+    'before exclude alice has 1 group feed'
+  )
+
+  await alice.tribes2.excludeMembers(groupId, [bobRoot.id]).catch((err) => {
+    console.error('remove member fail', err)
+    t.fail(err)
+  })
+
+  t.equals(
+    await p(countGroupFeeds)(alice),
+    2,
+    'after exclude alice has 2 group feeds'
+  )
+
+  const {
+    value: { author: secondFeedId },
+  } = await alice.tribes2
+    .publish({
+      type: 'test',
+      text: 'post',
+      recps: [groupId],
+    })
+    .catch(t.fail)
+
+  t.equals(
+    await p(countGroupFeeds)(alice),
+    2,
+    'alice still has 2 group feeds after publishing on the new feed'
+  )
+
+  t.notEquals(
+    secondFeedId,
+    firstFeedId,
+    'feed for publish is different to initial feed'
+  )
+
+  const { writeKey: writeKey2 } = await alice.tribes2.get(groupId)
+
+  t.false(writeKey1.key.equals(writeKey2.key), "there's a new key for writing")
+
+  const msgsFromFirst = await alice.db.query(
+    where(author(firstFeedId)),
+    toPromise()
+  )
+
+  const firstContents = msgsFromFirst.map((msg) => msg.value.content)
+
+  t.equal(firstContents.length, 5, '5 messages on first feed')
+
+  const firstInit = firstContents[0]
+
+  t.equal(firstInit.type, 'group/init')
+  t.equal(firstInit.groupKey, writeKey1.key.toString('base64'))
+
+  //const addAlice = firstContents[1]
+  //TODO
+
+  //const addBob = firstContents[2]
+  //TODO
+
+  //const excludeMsg = firstContents[3]
+
+  // TODO: test excludeMsg once we use the correct format
+
+  //const reinviteMsg = firstContents[4]
+
+  // TODO: test reinviteMsg once we use the correct format (add-member)
+
+  const msgsFromSecond = await alice.db.query(
+    where(author(secondFeedId)),
+    toPromise()
+  )
+
+  const secondContents = msgsFromSecond.map((msg) => msg.value.content)
+  console.log({ firstContents, secondContents })
+
+  t.equal(secondContents.length, 2, '2 messages on second (new) feed')
+
+  const secondInit = secondContents[0]
+
+  t.equal(secondInit.type, 'group/init')
+  t.equal(secondInit.version, 'v2')
+  t.equal(secondInit.groupKey, writeKey2.key.toString('base64'))
+  // TODO: test epoch tangle
+
+  const post = secondContents[1]
+
+  t.equal(post.text, 'post', 'found post on second feed')
+
+  await p(alice.close)(true)
+  await p(bob.close)(true)
+})