Merge branch 'remove-need-for-config' of CoBox/cobox-group-store into development

index.js

@@ -8,20 +8,18 @@ const maybe = require('call-me-maybe')
 
 const { uniq, isString } = require('./util')
 
-module.exports = (createGroup, storage, opts) => new GroupStore(createGroup, storage, opts)
+module.exports = (storage, factory, collection, opts) => new GroupStore(storage, factory, collection, opts)
 
 class GroupStore {
-  constructor (createGroup, storage, opts = {}) {
+  constructor (storage, factory, collection, opts = {}) {
     this._id = crypto.randomBytes(16).toString('hex')
-    this.root = storage || constants.storage
-    this.storage = path.join(this.root, 'groups')
-    this.config = opts.config
+    this.storage = storage
     this.opts = opts
-    this.createGroup = createGroup
+    this.factory = factory
 
-    this.groups = {}
-    this.config.groups.list().forEach((groupOpts, i) => {
-      this._cacheGroup(this._buildGroup(groupOpts))
+    this.collection = {}
+    collection.forEach((_opts, i) => {
+      this._cache(this._build(_opts))
     })
 
     this._readyCallback = thunky(this._ready.bind(this))
@@ -38,7 +36,7 @@ class GroupStore {
 
   async all () {
     await this.ready()
-    return uniq(Object.values(this.groups))
+    return uniq(Object.values(this.collection))
   }
 
   async where (params = {}) {
@@ -63,34 +61,15 @@ class GroupStore {
   }
 
   async create (params = {}) {
-    var group = await this.findBy(params)
-    if (group) throw new Error('group already exists')
+    var entry = await this.findBy(params)
+    if (entry) throw new Error('entry already exists')
+    var entry = this._build(params)
 
-    var group = this._buildGroup(params)
+    await entry.ready()
 
-    await group.ready()
-
-    this._cacheGroup(group)
-    this._saveGroup(group)
-
-    return group
-  }
-
-  // TODO: this doesn't work currently, throws a level db error
-  async destroy (params = {}) {
-    var group = await this.findBy(params)
-    if (!group) throw new Error('no group exists')
-
-    this.config.groups.delete(group.address)
-    // TODO: delete group data
-
-    if (this.config.save()) {
-      delete this.groups[group.address.toString('hex')]
-      return true
-    } else {
-      this.config.groups.set(group.address, group)
-      throw new Error('failed to save config file')
-    }
+    this._cache(entry)
+    entry.save()
+    return entry
   }
 
   // ------------------------------------------------------------------
@@ -98,14 +77,14 @@ class GroupStore {
   _ready (callback) {
     var pending = 1
     var self = this
-    var groups = Object.values(self.groups)
+    var collection = Object.values(self.collection)
 
     function next (n) {
-      var group = groups[n]
-      if (!group) return done()
+      var entry = collection[n]
+      if (!entry) return done()
       ++pending
       process.nextTick(next, n + 1)
-      group.ready(done)
+      entry.ready(done)
     }
 
     function done (err) {
@@ -121,33 +100,17 @@ class GroupStore {
     next(0)
   }
 
-  _buildGroup (params = {}) {
-    return this.createGroup(
+  _build (params = {}) {
+    return this.factory(
       this.storage,
       params.address,
       Object.assign(this.opts, params)
     )
   }
 
-  _cacheGroup (group) {
-    this.groups[group.address.toString('hex')] = group
-    if (group.name) this.groups[group.name] = group
-    return true
-  }
-
-  _saveGroup (group) {
-    this.config.groups.set(group.address, group.toConfig())
-    var success = this.config.save()
-    if (!success) return false
+  _cache (entry) {
+    this.collection[entry.address.toString('hex')] = entry
+    if (entry.name) this.collection[entry.name] = entry
     return true
   }
 }
-
-// _validate (id) {
-//   if (crypto.isKey(id)) key = id
-//   if (!crypto.isKey(id) && isString(id)) name = id
-//   // Ensure we either have no key, or the key is a valid key
-//   if (!(!key || crypto.isKey(key))) throw new Error('invalid: key format')
-//   return { key, name }
-// }
-

package.json

@@ -13,13 +13,15 @@
   "license": "AGPL-3.0-or-later",
   "dependencies": {
     "call-me-maybe": "^1.0.1",
-    "cobox-config": "git+https://ledger-git.dyne.org/cobox/cobox-config",
+    "cobox-config": "git+https://ledger-git.dyne.org/cobox/cobox-config#development",
     "cobox-constants": "^1.0.0",
-    "cobox-crypto": "git+https://ledger-git.dyne.org/cobox/cobox-crypto",
+    "cobox-crypto": "git+https://ledger-git.dyne.org/cobox/cobox-crypto#development",
     "debug": "^4.1.1",
     "thunky": "^1.1.0"
   },
   "devDependencies": {
+    "cobox-blind-replicator": "git+https://ledger-git.dyne.org/cobox/cobox-blind-replicator",
+    "cobox-group": "git+https://ledger-git.dyne.org/cobox/cobox-group#development",
     "mkdirp": "^0.5.1",
     "rimraf": "^3.0.0",
     "tap-spec": "^5.0.0",

test/index.test.js

@@ -4,7 +4,8 @@ const crypto = require('cobox-crypto')
 const Store = require('../')
 
 const { tmp, cleanup } = require('./util')
-const { createGroup } = require('./mocks')
+const Group = require('cobox-group/test/mock')
+const BlindReplicator = require('cobox-blind-replicator/test/mock')
 
 describe('group store: basic', (context) => {
   context('ready()', async function (assert, next) {
@@ -14,12 +15,13 @@ describe('group store: basic', (context) => {
 
     config.groups.set(params.address, params)
 
-    const store = Store(createGroup, storage, { config })
+    const collection = config.groups.list()
+    const store = Store(storage, Group, collection, { config })
 
     try {
       await store.ready()
-      assert.same(Object.values(store.groups).length, 1, 'builds then caches groups from the config')
-      assert.ok(store.groups[params.address.toString('hex')], 'accessible using address hex string')
+      assert.same(Object.values(store.collection).length, 1, 'builds then caches groups from the config')
+      assert.ok(store.collection[params.address.toString('hex')], 'accessible using address hex string')
     } catch (err) {
       assert.error(err, 'no error')
     }
@@ -34,7 +36,8 @@ describe('group store: basic', (context) => {
 
     config.groups.set(params.address, params)
 
-    const store = Store(createGroup, storage, { config })
+    const collection = config.groups.list()
+    const store = Store(storage, Group, collection, { config })
 
     try {
       await store.ready()
@@ -56,7 +59,8 @@ describe('group store: basic', (context) => {
     seedConfig()
     config.groups.set(params.address, params)
 
-    const store = Store(createGroup, storage, { config })
+    const collection = config.groups.list()
+    const store = Store(storage, Group, collection, { config })
 
     try {
       await store.ready()
@@ -66,9 +70,9 @@ describe('group store: basic', (context) => {
       })
 
       assert.ok(Array.isArray(response), 'returns an array')
-      var group = response[0]
-      assert.ok(group, 'finds a group')
-      assert.same(group && group.address, params.address, 'finds the correct group')
+      var entry = response[0]
+      assert.ok(entry, 'finds a entry')
+      assert.same(entry && entry.address, params.address, 'finds the correct entry')
     } catch (err) {
       assert.error(err, 'no error')
     }
@@ -93,7 +97,8 @@ describe('group store: basic', (context) => {
 
     config.groups.set(params.address, params)
 
-    const store = Store(createGroup, storage, { config })
+    const collection = config.groups.list()
+    const store = Store(storage, Group, collection, { config })
 
     try {
       await store.ready()
@@ -103,7 +108,7 @@ describe('group store: basic', (context) => {
         address: null
       })
 
-      assert.same(response.length, 0, 'fails to find a group')
+      assert.same(response.length, 0, 'fails to find an entry')
     } catch (err) {
       assert.error(err, 'no error')
     }
@@ -118,7 +123,8 @@ describe('group store: basic', (context) => {
 
     config.groups.set(params.address, params)
 
-    const store = Store(createGroup, storage, { config })
+    const collection = config.groups.list()
+    const store = Store(storage, Group, collection, { config })
 
     try {
       await store.ready()
@@ -128,7 +134,7 @@ describe('group store: basic', (context) => {
         address: params.address
       })
 
-      assert.same(response.length, 0, 'fails to find a group')
+      assert.same(response.length, 0, 'fails to find an entry')
     } catch (err) {
       assert.error(err, 'no error')
     }
@@ -143,7 +149,8 @@ describe('group store: basic', (context) => {
 
     config.groups.set(params.address, params)
 
-    const store = Store(createGroup, storage, { config })
+    const collection = config.groups.list()
+    const store = Store(storage, Group, collection, { config })
 
     try {
       await store.ready()
@@ -153,7 +160,7 @@ describe('group store: basic', (context) => {
         address: crypto.randomBytes(32).toString('hex')
       })
 
-      assert.same(response.length, 0, 'fails to find a group')
+      assert.same(response.length, 0, 'fails to find an entry')
     } catch (err) {
       assert.error(err, 'no error')
     }
@@ -168,7 +175,8 @@ describe('group store: basic', (context) => {
 
     config.groups.set(params.address, params)
 
-    const store = Store(createGroup, storage, { config })
+    const collection = config.groups.list()
+    const store = Store(storage, Group, collection, { config })
 
     try {
       await store.ready()
@@ -178,7 +186,7 @@ describe('group store: basic', (context) => {
         address: params.address
       })
 
-      assert.same(response.length, 0, 'fails to find a group')
+      assert.same(response.length, 0, 'fails to find an entry')
     } catch (err) {
       assert.error(err, 'no error')
     }
@@ -193,7 +201,8 @@ describe('group store: basic', (context) => {
 
     config.groups.set(params.address, params)
 
-    const store = Store(createGroup, storage, { config })
+    const collection = config.groups.list()
+    const store = Store(storage, Group, collection, { config })
 
     try {
       await store.ready()
@@ -217,7 +226,8 @@ describe('group store: basic', (context) => {
 
     config.groups.set(params.address, params)
 
-    const store = Store(createGroup, storage, { config })
+    const collection = config.groups.list()
+    const store = Store(storage, Group, collection, { config })
 
     try {
       await store.ready()
@@ -241,7 +251,8 @@ describe('group store: basic', (context) => {
 
     config.groups.set(params.address, params)
 
-    const store = Store(createGroup, storage, { config })
+    const collection = config.groups.list()
+    const store = Store(storage, Group, collection, { config })
 
     try {
       await store.ready()
@@ -261,7 +272,8 @@ describe('group store: basic', (context) => {
       config = Config(storage),
       params = Object.assign(crypto.keySet(), { name: 'magma' })
 
-    const store = Store(createGroup, storage, { config })
+    const collection = config.groups.list()
+    const store = Store(storage, Group, collection, { config })
 
     try {
       var group = await store.create(params)
@@ -278,7 +290,7 @@ describe('group store: basic', (context) => {
   //     params = crypto.keySet()
 
   //   config.groups.set(params.address, params)
-  //   const store = Store(createGroup, storage, { config })
+  //   const store = Store(Group, storage, { config })
 
   //   var groups = await store.all()
   //   console.log(groups.map((group) => group.address.toString('hex')))
@@ -288,3 +300,48 @@ describe('group store: basic', (context) => {
   //   cleanup(storage, next)
   // })
 })
+
+describe('multiple', (context) => {
+  context('factory', async (assert, next) => {
+    let storage = tmp(),
+      config = Config(storage),
+      group = crypto.keySet(),
+      replicator = { address: crypto.address() }
+
+    config.groups.set(group.address, group)
+    config.replicators.set(replicator.address, replicator)
+
+    const groups = config.groups.list()
+    const replicators = config.replicators.list()
+
+    const api = {
+      groups: {
+        store: Store(
+          storage,
+          Group,
+          groups,
+          { config }
+        )
+      },
+      replicators: {
+        store: Store(
+          storage,
+          BlindReplicator,
+          replicators,
+          { config }
+        )
+      }
+    }
+
+    await api.groups.store.ready()
+    await api.replicators.store.ready()
+
+    assert.same(Object.values(api.groups.store.collection).length, 1, 'builds then caches groups')
+    assert.same(Object.values(api.replicators.store.collection).length, 1, 'builds then caches replicators')
+
+    assert.ok(api.groups.store.collection[group.address.toString('hex')], 'accessible using address hex string')
+    assert.ok(api.replicators.store.collection[replicator.address.toString('hex')], 'accessible using address hex string')
+
+    cleanup(storage, next)
+  })
+})

test/mocks.js

@@ -1,21 +0,0 @@
-const maybe = require('call-me-maybe')
-
-function createGroup (storage, address, opts = {}) {
-  this.storage = storage
-  this.address = Buffer.from(address, 'hex')
-  this.encryptionKey = Buffer.from(opts.encryptionKey, 'hex')
-  this.name = opts.name
-}
-
-createGroup.prototype.ready = (callback) => maybe(callback, new Promise((resolve, reject) => resolve(true)))
-createGroup.prototype.toConfig = function () {
-  return {
-    name: this.name,
-    address: this.address,
-    encryptionKey: this.encryptionKey
-  }
-}
-
-module.exports = {
-  createGroup: (storage, address, opts) => new createGroup(storage, address, opts)
-}