Refactoring

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ezerous/breeze",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "A reactive data-store for OrbitDB.",
   "license": "MIT",
   "author": "Ezerous <ezerous@gmail.com>",
@@ -8,7 +8,7 @@
   "repository": "github:Ezerous/breeze",
   "dependencies": {
     "deepmerge": "~4.2.2",
-    "ipfs": "~0.51.0",
+    "ipfs": "~0.52.0",
     "is-plain-object": "~5.0.0",
     "orbit-db": "~0.26.0",
     "orbit-db-identity-provider": "~0.3.1",

src/Breeze.js

@@ -1,20 +1,19 @@
-import { BREEZE_INITIALIZING } from './breezeStatus/breezeActions'
+import { BREEZE_INITIALIZING } from "./breezeStatus/breezeActions"
 import defaultOptions from "./misc/defaultOptions";
-import merge from './misc/mergeUtils'
-import {createOrbitDatabase, orbitInit} from "./orbit/orbitActions";
+import merge from "./misc/mergeUtils"
+import {addOrbitDB, orbitInit} from "./orbit/orbitActions";
 
 // Load as promise so that async Breeze initialization can still resolve
 const isEnvReadyPromise = new Promise((resolve) => {
-    const hasWindow = typeof window !== 'undefined'
-    const hasDocument = typeof document !== 'undefined'
+    const hasWindow = typeof window !== 'undefined';
+    const hasDocument = typeof document !== 'undefined';
 
     if (hasWindow)
-        return window.addEventListener('load', resolve)
+        return window.addEventListener('load', resolve);
 
     // Resolve in any case if we missed the load event and the document is already loaded
-    if (hasDocument && document.readyState === `complete`) {
-        return resolve()
-    }
+    if (hasDocument && document.readyState === `complete`)
+        return resolve();
 })
 
 class Breeze {
@@ -28,9 +27,9 @@ class Breeze {
         this.ipfsOptions = options.ipfs;
         this.orbitOptions = options.orbit;
 
-        // Wait for window load event in case of injected web3.
+        // Wait for window load event
         isEnvReadyPromise.then(() => {
-            // Begin Breeze initialization.
+            // Begin Breeze initialization
             this.store.dispatch({
                 type: BREEZE_INITIALIZING,
                 breeze: this
@@ -39,12 +38,12 @@ class Breeze {
     }
 
     initOrbit(id) {
-        this.store.dispatch(orbitInit (this, id));
+        this.store.dispatch(orbitInit(this, id));
     }
 
-    // db = {name, type}
-    createOrbitDatabase (db){
-        this.store.dispatch(createOrbitDatabase (this.orbit, db));
+    // dbInfo = {name, type}    (where name can also be an address)
+    addOrbitDB (dbInfo){
+        this.store.dispatch(addOrbitDB(dbInfo));
     }
 }
 

src/orbit/orbitActions.js

@@ -9,17 +9,17 @@ export const ORBIT_IDENTITY_PROVIDER_ADDED = 'ORBIT_IDENTITY_PROVIDER_ADDED';
 export const ORBIT_IDENTITY_PROVIDER_FAILED = 'ORBIT_IDENTITY_PROVIDER_FAILED';
 
 // Database Status
-export const ORBIT_DATABASE_CREATING = 'ORBIT_DATABASE_CREATING';
-export const ORBIT_DATABASE_CREATED = 'ORBIT_DATABASE_CREATED';
-export const ORBIT_DATABASE_ALREADY_EXISTS = 'ORBIT_DATABASE_ALREADY_EXISTS';
-export const ORBIT_DATABASE_FAILED = 'ORBIT_DATABASE_FAILED';
-export const ORBIT_DATABASE_LISTEN = 'ORBIT_DATABASE_LISTEN';
+export const ORBIT_DB_ADD = 'ORBIT_DB_ADD';
+export const ORBIT_DB_ADDED = 'ORBIT_DB_ADDED';
+export const ORBIT_DB_ALREADY_ADDED = 'ORBIT_DB_ALREADY_ADDED';
+export const ORBIT_DB_FAILED = 'ORBIT_DB_FAILED';
+export const ORBIT_DB_LISTEN = 'ORBIT_DB_LISTEN';
 
 // Database Events
-export const ORBIT_DATABASE_READY = 'ORBIT_DATABASE_READY';
-export const ORBIT_DATABASE_REPLICATING = 'ORBIT_DATABASE_REPLICATING';
-export const ORBIT_DATABASE_REPLICATED = 'ORBIT_DATABASE_REPLICATED';
-export const ORBIT_DATABASE_WRITE = 'ORBIT_DATABASE_WRITE';
+export const ORBIT_DB_READY = 'ORBIT_DB_READY';
+export const ORBIT_DB_REPLICATING = 'ORBIT_DB_REPLICATING';
+export const ORBIT_DB_REPLICATED = 'ORBIT_DB_REPLICATED';
+export const ORBIT_DB_WRITE = 'ORBIT_DB_WRITE';
 
 export function orbitInit (breeze, id) {
     return {
@@ -29,11 +29,11 @@ export function orbitInit (breeze, id) {
     }
 }
 
-export function createOrbitDatabase (orbit, db) {
+// dbInfo = {address, type}    (where address can also be a name)
+export function addOrbitDB (dbInfo) {
     return {
-        type: ORBIT_DATABASE_CREATING,
-        orbit,
-        db
+        type: ORBIT_DB_ADD,
+        dbInfo
     }
 }
 

src/orbit/orbitReducer.js

@@ -1,12 +1,12 @@
 import {
-    ORBIT_DATABASE_CREATED,
-    ORBIT_DATABASE_READY,
-    ORBIT_DATABASE_REPLICATED,
-    ORBIT_DATABASE_REPLICATING,
+    ORBIT_DB_ADDED,
+    ORBIT_DB_READY,
+    ORBIT_DB_REPLICATED,
+    ORBIT_DB_REPLICATING,
     ORBIT_INITIALIZING,
     ORBIT_INITIALIZED,
     ORBIT_INIT_FAILED,
-    ORBIT_DATABASE_WRITE
+    ORBIT_DB_WRITE
 } from "./orbitActions";
 
 import {
@@ -41,15 +41,15 @@ const orbitReducer = (state = initialState, action) => {
                 ...state,
                 status: STATUS_FAILED
             };
-        case ORBIT_DATABASE_CREATED:
+        case ORBIT_DB_ADDED:
             return newDatabasesStatus(state, action, DB_STATUS_INIT);
-        case ORBIT_DATABASE_READY:
+        case ORBIT_DB_READY:
             return newDatabasesStatus(state, action, DB_STATUS_READY);
-        case ORBIT_DATABASE_REPLICATING:
+        case ORBIT_DB_REPLICATING:
             return newDatabasesStatus(state, action, DB_STATUS_REPLICATING);
-        case ORBIT_DATABASE_REPLICATED:
+        case ORBIT_DB_REPLICATED:
             return newDatabasesStatus(state, action, DB_STATUS_REPLICATED);
-        case ORBIT_DATABASE_WRITE:
+        case ORBIT_DB_WRITE:
             return newDatabasesStatus(state, action, DB_STATUS_WRITTEN);
         default:
             return state;

src/orbit/orbitSaga.js

@@ -4,25 +4,26 @@ import OrbitDB from 'orbit-db';
 import Identities from 'orbit-db-identity-provider'
 
 import {
-    ORBIT_DATABASE_ALREADY_EXISTS,
-    ORBIT_DATABASE_CREATED,
-    ORBIT_DATABASE_CREATING,
-    ORBIT_DATABASE_FAILED,
-    ORBIT_DATABASE_LISTEN,
-    ORBIT_DATABASE_READY,
-    ORBIT_DATABASE_REPLICATED,
-    ORBIT_DATABASE_REPLICATING,
-    ORBIT_DATABASE_WRITE,
+    ORBIT_DB_ADDED,
+    ORBIT_DB_ADD,
+    ORBIT_DB_FAILED,
+    ORBIT_DB_LISTEN,
+    ORBIT_DB_READY,
+    ORBIT_DB_REPLICATED,
+    ORBIT_DB_REPLICATING,
+    ORBIT_DB_WRITE,
     ORBIT_IDENTITY_PROVIDER_ADD,
     ORBIT_IDENTITY_PROVIDER_ADDED,
     ORBIT_IDENTITY_PROVIDER_FAILED,
     ORBIT_INIT_FAILED,
     ORBIT_INITIALIZED,
-    ORBIT_INITIALIZING
+    ORBIT_INITIALIZING, ORBIT_DB_ALREADY_ADDED
 } from './orbitActions';
 
 const LOGGING_PREFIX = 'orbitSaga: ';
 
+let orbit = {};
+
 /*
  * Add Orbit Identity Provider
  */
@@ -49,13 +50,13 @@ function * initOrbit(action) {
 
         const identity = yield call(Identities.createIdentity, { id, type: identityProvider.type});
 
-        const orbit = yield call (OrbitDB.createInstance, ...[ipfs, { identity }]);
+        orbit = yield call (OrbitDB.createInstance, ...[ipfs, { identity }]);
 
         breeze.orbit = orbit;
 
         // Create initial databases from options
-        yield all(databases.map(db => {
-            return call(createDatabase, { orbit, db });
+        yield all(databases.map(dbInfo => {
+            return call(addDatabase, {dbInfo});
         }));
 
         yield put({ type: ORBIT_INITIALIZED, orbit });
@@ -72,39 +73,43 @@ function * initOrbit(action) {
 let databases = new Set();
 
 /*
- * Creates and loads an orbit database given a name and a type as its parameters
- * Note: db.name can also be an OrbitDB address
+ * Adds an Orbit database to the set of the tracked databases. The database is created and loaded, with an event channel
+ * that listens to emitted events and dispatches corresponding actions.
+ * dbInfo = {address, type}    (where address can also be a name)
  */
-function * createDatabase({ orbit, db }) {
+function * addDatabase({dbInfo}) {
     try {
+        let {address, type} = dbInfo;
+        if(!OrbitDB.isValidAddress(address))
+            address = yield call([orbit, orbit.determineAddress],...[address, type]);
+
         const { size } = databases;
-        databases.add(orbit.id + db.name);
+        databases.add(address);
 
         if (databases.size > size) {
-            const createdDB = yield call([orbit, orbit.open], ...[db.name, { type: db.type, create: true }]);
+            const createdDB = yield call([orbit, orbit.open], ...[address, { type, create: true }]);
 
-            yield put({ type: ORBIT_DATABASE_CREATED, database: createdDB, timestamp: +new Date });
+            yield put({ type: ORBIT_DB_ADDED, database: createdDB, timestamp: +new Date });
 
             // Event channel setup
             yield spawn(callListenForOrbitDatabaseEvent, { database: createdDB });
 
             // Wait for event channel setup before loading
-            yield take(action => action.type === ORBIT_DATABASE_LISTEN && action.id === createdDB.id);
+            yield take(action => action.type === ORBIT_DB_LISTEN && action.id === createdDB.id);
 
             yield call([createdDB, createdDB.load]);
 
             return createdDB;
         }
         else
-            yield put({ type: ORBIT_DATABASE_ALREADY_EXISTS, database: db.name });
+            yield put({ type: ORBIT_DB_ALREADY_ADDED, address });
     } catch (error) {
-        yield put({ type: ORBIT_DATABASE_FAILED, error });
+        yield put({ type: ORBIT_DB_FAILED, error });
         console.error(LOGGING_PREFIX + 'OrbitDB database creation error:');
         console.error(error);
     }
 }
 
-
 /*
  * Database Events
  * See also https://redux-saga.js.org/docs/advanced/Channels.html
@@ -112,16 +117,16 @@ function * createDatabase({ orbit, db }) {
 function createOrbitDatabaseChannel (database){
     return eventChannel(emit => {
         const onReady = () => {
-            emit({ type: ORBIT_DATABASE_READY, database, timestamp: +new Date });
+            emit({ type: ORBIT_DB_READY, database, timestamp: +new Date });
         };
         const onReplicate = () => {
-            emit({ type: ORBIT_DATABASE_REPLICATING, database, timestamp: +new Date });
+            emit({ type: ORBIT_DB_REPLICATING, database, timestamp: +new Date });
         };
         const onReplicated = () => {
-            emit({ type: ORBIT_DATABASE_REPLICATED, database, timestamp: +new Date });
+            emit({ type: ORBIT_DB_REPLICATED, database, timestamp: +new Date });
         };
         const onWrite = (address, entry) => {
-            emit({ type: ORBIT_DATABASE_WRITE, database, entry, timestamp: +new Date });
+            emit({ type: ORBIT_DB_WRITE, database, entry, timestamp: +new Date });
         };
 
         const eventListener = database.events
@@ -142,7 +147,7 @@ function createOrbitDatabaseChannel (database){
 
 function * callListenForOrbitDatabaseEvent ({ database }) {
     const orbitDatabaseChannel = yield call(createOrbitDatabaseChannel, database);
-    yield put({type: ORBIT_DATABASE_LISTEN, id: database.id});
+    yield put({type: ORBIT_DB_LISTEN, id: database.id});
 
     try {
         while (true) {
@@ -156,7 +161,7 @@ function * callListenForOrbitDatabaseEvent ({ database }) {
 
 function * orbitSaga () {
     yield takeLatest(ORBIT_INITIALIZING, initOrbit);
-    yield takeEvery(ORBIT_DATABASE_CREATING, createDatabase);
+    yield takeEvery(ORBIT_DB_ADD, addDatabase);
 }
 
 export default orbitSaga