Patchwork integration

README.md

@@ -85,14 +85,14 @@ Returns a stream of shard messages identified by root id.  Takes `opts` - standa
 Returns a stream of shards others have shared with you. Takes `opts` - standard stream options like `live`, `reverse` etc.
 
 
-
 ### Shard forward methods 
 
-#### `darkCrystal.forward.async.publish(root, recp, callback)`
+#### `darkCrystal.forward.async.publish({ root, recp, requestId } callback)`
 
-Takes arguments
+Takes an object with properties: 
 - `root` the id of the root message with which the shard is associated
 - `recp` the feedId of the recipient of the forwarded shard
+- `requestId` the id of an associated `dark-crystal/forward-request` message (optional)
 
 Publishes a forward message which allows a shard to be sent to someone other than the owner of the secret.
 
@@ -104,6 +104,30 @@ Returns a stream of forwarded shard messages identified by root id.  Takes `opts
 
 Returns a stream of all forwarded shards you have recieved. Takes `opts` - standard stream options like `live`, `reverse` etc.
 
+### Forward request methods
+
+#### `darkCrystal.forwardRequest.async.publish-all({ secretOwner, recps })` 
+
+Takes an object with properties:
+- `secretOwner` the feedId of the owner of the secret of which the shards are being requested
+- `recps` an array of feedIds of the recipients of the request (who should be the holders of the shards being requested)
+
+Publishes a request to the given recipients that they forward you shards. Note that the request does not specify a rootId, since we can assume the rootId is unknown to the person requesting a forward. Forward requests are currently optional. 
+
+#### `darkCrystal.forwardRequest.pull.bySecretOwner(secretOwner, opts)`
+
+Returns a stream of forward requests for shards authored by a given feedId.
+`opts` are standard stream options.
+
+#### `darkCrystal.forwardRequest.pull.forOwnShards(filter, opts)`
+
+Returns a stream of forward requests for shards which you hold. `filter` is an optional argument which, if given, is a function returning a boolean which is applied as a filter to the stream. 
+`opts` are standard stream options.
+
+#### `darkCrystal.forwardRequest.pull.fromSelf(opts)`
+
+Returns a stream of forward requests which you authored (to others).
+`opts` are standard stream options.
 
 ### Validators
 

forward-request/async/build.js

@@ -0,0 +1,18 @@
+const { isForwardRequest } = require('ssb-dark-crystal-schema')
+
+module.exports = function (server) {
+  return function buildForwardRequest ({ secretOwner, recp }, callback) {
+    var content = {
+      type: 'dark-crystal/forward-request',
+      version: '1.0.0',
+      secretOwner,
+      recps: [recp, server.id]
+    }
+
+    // TODO: check that secretOwner !== recp or sever.id
+
+    if (!isForwardRequest(content)) return callback(isForwardRequest.errors)
+
+    callback(null, content)
+  }
+}

forward-request/async/publish-all.js

@@ -0,0 +1,40 @@
+const pull = require('pull-stream')
+const { isFeed } = require('ssb-ref')
+
+const buildForwardRequest = require('../async/build')
+const publish = require('../../lib/publish-msg')
+
+module.exports = function (server) {
+  return function publishAll ({ secretOwner, recps }, callback) {
+    let feedIds = recps
+      .map(recp => typeof recp === 'string' ? recp : recp.link)
+      .filter(Boolean)
+      .filter(isFeed)
+
+    if (feedIds.length !== recps.length) return callback(new Error('forwardRequests publishAll: all recps must be valid feedIds'), recps)
+    if (!validRecps(feedIds)) return callback(new Error('forwardRequests publishAll: all recps must be valid feedIds', feedIds))
+    if (!isFeed(secretOwner)) return callback(new Error('forwardRequests publishAll: invalid feedId', secretOwner))
+
+    pull(
+      pull.values(feedIds.map(recp => ({ secretOwner, recp }))),
+      pull.asyncMap(buildForwardRequest(server)),
+      pull.collect((err, forwardRequests) => {
+        if (err) return callback(err)
+
+        publishAll(forwardRequests)
+      })
+    )
+
+    function publishAll (forwardRequests) {
+      pull(
+        pull.values(forwardRequests),
+        pull.asyncMap(publish(server)),
+        pull.collect(callback)
+      )
+    }
+  }
+}
+
+function validRecps (recps) {
+  return recps.every(isFeed)
+}

forward-request/pull/by-secret-owner.js

@@ -0,0 +1,35 @@
+const pull = require('pull-stream')
+const next = require('pull-next-query')
+const { isForwardRequest } = require('ssb-dark-crystal-schema')
+const { isFeedId } = require('ssb-ref')
+
+module.exports = function (server) {
+  return function bySecretOwner (secretOwner, opts = {}) {
+    assert(isFeedId(secretOwner), 'secretOwner must be a valid feedId')
+    const query = [{
+      $filter: {
+        value: {
+          timestamp: { $gt: 0 }, // needed for pull-next-query to stepOn on published timestamp
+          content: { type: 'dark-crystal/forward-request' }
+        }
+      }
+    }, {
+      $filter: {
+        value: {
+          content: { secretOwner }
+        }
+      }
+    }]
+
+    const _opts = Object.assign({}, { query, limit: 100 }, opts)
+
+    return pull(
+      next(server.query.read, _opts),
+      pull.filter(isForwardRequest)
+    )
+  }
+}
+
+function assert (test, message) {
+  if (!test) throw new Error(message || 'AssertionError')
+}

forward-request/pull/for-own-shards.js

@@ -0,0 +1,25 @@
+const pull = require('pull-stream')
+// const next = require('pull-next-query')
+const ShardsFromOthers = require('../../shard/pull/from-others')
+const forwardRequestBySecretOwner = require('./by-secret-owner')
+const { get } = require('lodash')
+
+module.exports = function (server) {
+  const shardsFromOthers = ShardsFromOthers(server)
+
+  return function forOwnShards (opts = {}) {
+    return pull(
+      shardsFromOthers(),
+      pull.unique(s => get(s, 'value.author')),
+      pull.asyncMap((shard, cb) => {
+        pull(
+          forwardRequestBySecretOwner(get(shard, 'value.author')),
+          pull.collect((err, forwards) => {
+            if (err) cb(err)
+            cb(null, forwards)
+          })
+        )
+      })
+    )
+  }
+}

forward-request/pull/from-others.js

@@ -0,0 +1,29 @@
+const pull = require('pull-stream')
+const next = require('pull-next-query')
+const { isForwardRequest } = require('ssb-dark-crystal-schema')
+
+module.exports = function (server) {
+  return function fromOthers (opts = {}) {
+    const query = [{
+      $filter: {
+        value: {
+          timestamp: { $gt: 0 }, // needed for pull-next-query to stepOn on published timestamp
+          content: { type: 'dark-crystal/forward-request' }
+        }
+      }
+    }, {
+      $filter: {
+        value: {
+          author: { $ne: server.id }
+        }
+      }
+    }]
+
+    const _opts = Object.assign({}, { query, limit: 100 }, opts)
+
+    return pull(
+      next(server.query.read, _opts),
+      pull.filter(isForwardRequest)
+    )
+  }
+}

forward-request/pull/from-self.js

@@ -0,0 +1,29 @@
+const pull = require('pull-stream')
+const next = require('pull-next-query')
+const { isForwardRequest } = require('ssb-dark-crystal-schema')
+
+module.exports = function (server) {
+  return function fromSelf (opts = {}) {
+    const query = [{
+      $filter: {
+        value: {
+          timestamp: { $gt: 0 }, // needed for pull-next-query to stepOn on published timestamp
+          content: { type: 'dark-crystal/forward-request' }
+        }
+      }
+    }, {
+      $filter: {
+        value: {
+          author: server.id
+        }
+      }
+    }]
+
+    const _opts = Object.assign({}, { query, limit: 100 }, opts)
+
+    return pull(
+      next(server.query.read, _opts),
+      pull.filter(isForwardRequest)
+    )
+  }
+}

forward/async/build.js

@@ -1,7 +1,7 @@
 const isForward = require('../../isForward')
 
 module.exports = function buildShard (server) {
-  return function ({ root, shard, shareVersion, recp }, cb) {
+  return function ({ root, shard, shardId, requestId, shareVersion, recp }, cb) {
     // this undoes the privatebox packing we've used to encrypt shards
     server.private.unbox(shard, (err, theDecryptedShard) => {
       if (err) return cb(err)
@@ -11,6 +11,8 @@ module.exports = function buildShard (server) {
         version: '1.0.0',
         root,
         shard: theDecryptedShard,
+        shardId,
+        requestId,
         shareVersion,
         recps: [recp, server.id]
       }

forward/async/publish.js

@@ -7,7 +7,7 @@ const publish = require('../../lib/publish-msg')
 
 module.exports = function (server) {
   const pullShardsByRoot = PullShardsByRoot(server)
-  return function publishForward (root, recp, callback) {
+  return function publishForward ({ root, recp, requestId }, callback) {
     if (!ref.isMsgId(root)) return callback(new Error('Invalid rootId'))
     pull(
       pullShardsByRoot(root),
@@ -27,12 +27,11 @@ module.exports = function (server) {
         }
 
         const shareVersion = get(shards[0], 'value.content.version')
-
+        const shardId = get(shards[0], 'key')
         const shard = get(shards[0], 'value.content.shard')
 
-        buildForward(server)({ root, shard, shareVersion, recp }, (err, content) => {
+        buildForward(server)({ root, shard, shardId, requestId, shareVersion, recp }, (err, content) => {
           if (err) return callback(err)
-
           publish(server)(content, callback)
         })
       })

lib/assert.js

@@ -0,0 +1,3 @@
+module.exports = function assert (test, message) {
+  if (!test) throw new Error(message || 'AssertionError')
+}

lib/unpackLink.js

@@ -0,0 +1,12 @@
+const assert = require('./assert')
+const { isBlobId } = require('ssb-ref')
+
+module.exports = function unpackLink (link) {
+  const index = link.indexOf('?')
+  const blobId = link.substring(0, index)
+  const blobKey = link.substring(index + 1)
+  assert(((index > 0) && (blobKey.length)), 'Blob not encrypted')
+  // TODO: test for well formed blob key
+  assert((isBlobId(blobId)), 'attachment contains invalid blob reference')
+  return { blobId, blobKey }
+}

methods.js

@@ -1,4 +1,4 @@
-const { isRitual, isRoot, isShard, isForward } = require('ssb-dark-crystal-schema')
+const { isRitual, isRoot, isShard, isForward, isForwardRequest } = require('ssb-dark-crystal-schema')
 const isRequest = require('./isRequest')
 const isReply = require('./isReply')
 
@@ -56,12 +56,23 @@ module.exports = {
       fromOthersByRoot: require('./forward/pull/from-others-by-root')
     }
   },
+  forwardRequest: {
+    async: {
+      publishAll: require('./forward-request/async/publish-all')
+    },
+    pull: {
+      bySecretOwner: require('./forward-request/pull/by-secret-owner'),
+      fromSelf: require('./forward-request/pull/from-self'),
+      forOwnShards: require('./forward-request/pull/for-own-shards')
+    }
+  },
   sync: {
     isRitual: () => isRitual,
     isRoot: () => isRoot,
     isShard: () => isShard,
     isForward: () => isForward,
     isRequest: () => isRequest,
-    isReply: () => isReply
+    isReply: () => isReply,
+    isForwardRequest: () => isForwardRequest
   }
 }

shard/async/build.js

@@ -1,17 +1,22 @@
 const { box } = require('ssb-keys')
 const { isShard, errorParser } = require('ssb-dark-crystal-schema')
+const { pickBy, identity } = require('lodash')
 // TODO - change to use secretbox from sodium?
 
 module.exports = function buildShard (server) {
-  return function ({ root, shard, recp }, cb) {
-    const content = {
+  return function ({ root, shard, recp, attachment }, cb) {
+    var content = {
       type: 'dark-crystal/shard',
       version: '2.0.0',
       root,
       shard: box(shard, [recp]),
-      recps: [recp, server.id]
+      recps: [recp, server.id],
+      attachment
     }
 
+    // remove falsey values
+    content = pickBy(content, identity)
+
     if (!isShard(content)) return cb(errorParser(content))
 
     cb(null, content)

shard/async/publish-all.js

@@ -5,13 +5,13 @@ const buildShard = require('../async/build')
 const publish = require('../../lib/publish-msg')
 
 module.exports = function (server) {
-  return function publishAll ({ shards, recps, rootId }, callback) {
+  return function publishAll ({ shards, recps, rootId, attachment }, callback) {
     if (!validRecps(recps)) return callback(new Error('shards publishAll: all recps must be valid feedIds', recps))
     if (!isMsg(rootId)) return callback(new Error('shard publishAll: invalid rootId', rootId))
     if (shards.length !== recps.length) return callback(new Error('shard publishAll: need as many shards as recps'))
 
     const opts = shards.map((shard, i) => {
-      return { root: rootId, shard, recp: recps[i] }
+      return { root: rootId, shard, recp: recps[i], attachment }
     })
 
     pull(