Patchwork integration

forward-request/async/build.js

@@ -0,0 +1,18 @@
+const { isForwardRequest, errorParser } = 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 { isMsg, 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,32 @@
+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 (filter, opts = {}) {
+    if ((typeof filter === 'object') && (opts === null)) {
+      opts = filter
+      filter = null
+    }
+    if (!filter) filter = () => { return true } // don't filter anything
+
+    return pull(
+      shardsFromOthers(),
+      // pull.filter(filter),
+      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

@@ -4,9 +4,11 @@ const get = require('lodash.get')
 const PullShardsByRoot = require('../../shard/pull/by-root')
 const buildForward = require('./build')
 const publish = require('../../lib/publish-msg')
+const PullForwardRequestsSecretOwner = require('../../forward-request/pull/by-secret-owner')
 
 module.exports = function (server) {
   const pullShardsByRoot = PullShardsByRoot(server)
+  const pullForwardRequestsSecretOwner = PullForwardRequestsSecretOwner(server)
   return function publishForward (root, recp, callback) {
     if (!ref.isMsgId(root)) return callback(new Error('Invalid rootId'))
     pull(
@@ -25,16 +27,26 @@ module.exports = function (server) {
         if (get(shards[0], 'value.author') === recp) {
           return callback(new Error('You may not forward a shard to its author. Use reply instead.'))
         }
-
-        const shareVersion = get(shards[0], 'value.content.version')
-
-        const shard = get(shards[0], 'value.content.shard')
-
-        buildForward(server)({ root, shard, shareVersion, recp }, (err, content) => {
-          if (err) return callback(err)
-
-          publish(server)(content, callback)
-        })
+        pull(
+          pullForwardRequestsSecretOwner(get(shards[0], 'value.author')),
+          pull.collect((err, forwardRequests) => {
+            var requestId = null
+            if (err) return callback(err)
+            if (forwardRequests.length > 0) {
+              requestId = forwardRequests[0]
+            }
+
+            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, 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
   }
 }