blind-peer 0.0.2 → 0.0.4

package/bin.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+
+const { command, flag } = require('paparam')
+const goodbye = require('graceful-goodbye')
+const idEnc = require('hypercore-id-encoding')
+const BlindPeer = require('.')
+
+const cmd = command('blind-peer',
+  flag('--storage|-s [path]', 'storage path, defaults to ./blind-peer'),
+  async function ({ flags }) {
+    console.info('Starting blind peer')
+
+    const storage = flags.storage || 'blind-peer'
+    const blindPeer = new BlindPeer(storage)
+
+    blindPeer.on('add-request', req => {
+      try {
+        console.log(`Add-mailbox request received for autobase ${idEnc.normalize(req.autobase)}`)
+      } catch {
+        console.log('Invalid add-mailbox request received')
+        console.log(req)
+      }
+    })
+
+    blindPeer.on('post-request', req => {
+      try {
+        console.log(`Post request received to autobase ${idEnc.normalize(req.autobase)}`)
+      } catch {
+        console.log('Invalid post request received')
+        console.log(req)
+      }
+    })
+
+    console.info(`Using storage '${storage}'`)
+
+    goodbye(async () => {
+      console.info('Shutting down blind peer')
+      await blindPeer.close()
+    })
+
+    await blindPeer.listen()
+
+    blindPeer.swarm.on('connection', (conn, peerInfo) => {
+      const key = idEnc.normalize(peerInfo.publicKey)
+      console.log(`Opened connection to ${key}`)
+      conn.on('close', () => console.log(`Closed connection to ${key}`))
+    })
+
+    console.info(`Listening at ${idEnc.normalize(blindPeer.publicKey)}`)
+  }
+)
+
+cmd.parse()

package/build.js

@@ -90,7 +90,7 @@ blind.register({
 
 Hyperschema.toDisk(schema)
 
-const db = HyperDB.from(SCHEMA_DIR, DB_DIR)
+const db = HyperDB.from(SCHEMA_DIR, DB_DIR, { offset: 64 })
 const blindDB = db.namespace('blind-peer')
 
 blindDB.collections.register({

package/example/autobase.mjs

@@ -4,6 +4,7 @@ import c from 'compact-encoding'
 import Corestore from 'corestore'
 import Hyperswarm from 'hyperswarm'
 import debounce from 'debounceify'
+import IdEnc from 'hypercore-id-encoding'
 
 const base = new Autobase(new Corestore('/tmp/my-corestore'), {
   encryptionKey: Buffer.alloc(30).fill('secret'),
@@ -31,7 +32,7 @@ base.view.on('append', debounce(async function () {
 }))
 
 // TODO: record in autobase
-const publicKey = Buffer.from(process.argv[2], 'hex')
+const publicKey = IdEnc.decode(process.argv[2])
 
 const s = new Hyperswarm({ keyPair: await base.store.createKeyPair('tmp') })
 

package/example/post.mjs

@@ -1,8 +1,9 @@
 import BlindPeerClient from '../client.js'
 import Hyperswarm from 'hyperswarm'
+import IdEnc from 'hypercore-id-encoding'
 
-const publicKey = Buffer.from(process.argv[2], 'hex')
-const autobase = Buffer.from(process.argv[3], 'hex')
+const publicKey = IdEnc.decode(process.argv[2])
+const autobase = IdEnc.decode(process.argv[3])
 const rawMessage = process.argv[4]
 const message = Buffer.from(
   JSON.stringify({ mailbox: true, message: rawMessage })

package/index.js

@@ -1,3 +1,4 @@
+const { EventEmitter } = require('events')
 const AutobaseLightWriter = require('autobase-light-writer')
 const HyperDB = require('hyperdb')
 const Corestore = require('corestore')
@@ -8,8 +9,10 @@ const Hyperswarm = require('hyperswarm')
 const ProtomuxRPC = require('protomux-rpc')
 const c = require('compact-encoding')
 
-module.exports = class BlindPeer {
+module.exports = class BlindPeer extends EventEmitter {
   constructor (storage) {
+    super()
+
     this.db = HyperDB.rocks(path.join(storage, 'hyperdb'), definition)
     this.store = new Corestore(path.join(storage, 'corestore'))
     this.store.on('core-open', this._oncoreopen.bind(this))
@@ -36,7 +39,9 @@ module.exports = class BlindPeer {
   }
 
   async _onrpcadd (req) {
+    this.emit('add-request', req)
     const res = await this.add(req)
+    this.emit('add-response', req, res)
 
     return {
       autobase: res.autobase,
@@ -46,7 +51,11 @@ module.exports = class BlindPeer {
   }
 
   async _onrpcpost (req) {
-    return await this.post(req)
+    this.emit('post-request', req)
+    const res = await this.post(req)
+    this.emit('post-response', req, res)
+
+    return res
   }
 
   async _oncoreopen (core) {

package/package.json

@@ -1,14 +1,20 @@
 {
   "name": "blind-peer",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "WIP - nothing to see here",
   "main": "index.js",
+  "bin": {
+    "blind-peer": "bin.js"
+  },
   "dependencies": {
     "autobase-light-writer": "^1.1.0",
     "corestore": "^6.18.4",
+    "graceful-goodbye": "^1.3.2",
+    "hypercore-id-encoding": "^1.3.0",
     "hyperdb": "^4.1.2",
     "hyperschema": "^1.0.3",
     "hyperswarm": "^4.8.4",
+    "paparam": "^1.6.1",
     "protomux-rpc": "^1.6.0"
   },
   "devDependencies": {

package/spec/hyperdb/db.json

@@ -1,11 +1,11 @@
 {
   "version": 0,
-  "offset": 0,
+  "offset": 64,
   "schema": [
     {
       "name": "mailbox",
       "namespace": "blind-peer",
-      "id": 0,
+      "id": 64,
       "type": 1,
       "indexes": [],
       "schema": "@blind-peer/mailbox",

package/spec/hyperdb/index.js

@@ -6,18 +6,18 @@ const { IndexEncoder, c } = require('hyperdb/runtime')
 const { version, resolveStruct } = require('./messages.js')
 
 // '@blind-peer/mailbox' collection key
-const collection0_key = new IndexEncoder([
+const collection64_key = new IndexEncoder([
   IndexEncoder.BUFFER
-], { prefix: 0 })
+], { prefix: 64 })
 
-function collection0_indexify (record) {
+function collection64_indexify (record) {
   const a = record.autobase
   return a === undefined ? [] : [a]
 }
 
 // '@blind-peer/mailbox' reconstruction function
-function collection0_reconstruct (version, keyBuf, valueBuf) {
-  const key = collection0_key.decode(keyBuf)
+function collection64_reconstruct (version, keyBuf, valueBuf) {
+  const key = collection64_key.decode(keyBuf)
   const value = c.decode(resolveStruct('@blind-peer/mailbox/value', version), valueBuf)
   // TODO: This should be fully code generated
   return {
@@ -26,42 +26,42 @@ function collection0_reconstruct (version, keyBuf, valueBuf) {
   }
 }
 // '@blind-peer/mailbox' key reconstruction function
-function collection0_reconstruct_key (keyBuf) {
-  const key = collection0_key.decode(keyBuf)
+function collection64_reconstruct_key (keyBuf) {
+  const key = collection64_key.decode(keyBuf)
   return {
     autobase: key[0]
   }
 }
 
 // '@blind-peer/mailbox'
-const collection0 = {
+const collection64 = {
   name: '@blind-peer/mailbox',
-  id: 0,
+  id: 64,
   encodeKey (record) {
     const key = [record.autobase]
-    return collection0_key.encode(key)
+    return collection64_key.encode(key)
   },
   encodeKeyRange ({ gt, lt, gte, lte } = {}) {
-    return collection0_key.encodeRange({
-      gt: gt ? collection0_indexify(gt) : null,
-      lt: lt ? collection0_indexify(lt) : null,
-      gte: gte ? collection0_indexify(gte) : null,
-      lte: lte ? collection0_indexify(lte) : null
+    return collection64_key.encodeRange({
+      gt: gt ? collection64_indexify(gt) : null,
+      lt: lt ? collection64_indexify(lt) : null,
+      gte: gte ? collection64_indexify(gte) : null,
+      lte: lte ? collection64_indexify(lte) : null
     })
   },
   encodeValue (version, record) {
     return c.encode(resolveStruct('@blind-peer/mailbox/value', version), record)
   },
   trigger: null,
-  reconstruct: collection0_reconstruct,
-  reconstructKey: collection0_reconstruct_key,
+  reconstruct: collection64_reconstruct,
+  reconstructKey: collection64_reconstruct_key,
   indexes: []
 }
 
 module.exports = {
   version,
   collections: [
-    collection0
+    collection64
   ],
   indexes: [
   ],
@@ -71,7 +71,7 @@ module.exports = {
 
 function resolveCollection (name) {
   switch (name) {
-    case '@blind-peer/mailbox': return collection0
+    case '@blind-peer/mailbox': return collection64
     default: return null
   }
 }