ECEntrics
/
breeze
mirror of https://gitlab.com/ecentrics/breeze
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Refactoring

develop
Ezerous 4 years ago
parent
e1ea15b79f
commit
4330841347
6 changed files with 269 additions and 1754 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 4
      package.json
  2. 27
      src/Breeze.js
  3. 26
      src/orbit/orbitActions.js
  4. 20
      src/orbit/orbitReducer.js
  5. 63
      src/orbit/orbitSaga.js
  6. 1881
      yarn.lock

4
package.json
View File

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

27
src/Breeze.js
View File

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

26
src/orbit/orbitActions.js
View File

@ -9,17 +9,17 @@ export const ORBIT_IDENTITY_PROVIDER_ADDED = 'ORBIT_IDENTITY_PROVIDER_ADDED';
export const ORBIT_IDENTITY_PROVIDER_FAILED = 'ORBIT_IDENTITY_PROVIDER_FAILED'; export const ORBIT_IDENTITY_PROVIDER_FAILED = 'ORBIT_IDENTITY_PROVIDER_FAILED';
// Database Status // Database Status
export const ORBIT_DATABASE_CREATING = 'ORBIT_DATABASE_CREATING'; export const ORBIT_DB_ADD = 'ORBIT_DB_ADD';
export const ORBIT_DATABASE_CREATED = 'ORBIT_DATABASE_CREATED'; export const ORBIT_DB_ADDED = 'ORBIT_DB_ADDED';
export const ORBIT_DATABASE_ALREADY_EXISTS = 'ORBIT_DATABASE_ALREADY_EXISTS'; export const ORBIT_DB_ALREADY_ADDED = 'ORBIT_DB_ALREADY_ADDED';
export const ORBIT_DATABASE_FAILED = 'ORBIT_DATABASE_FAILED'; export const ORBIT_DB_FAILED = 'ORBIT_DB_FAILED';
export const ORBIT_DATABASE_LISTEN = 'ORBIT_DATABASE_LISTEN'; export const ORBIT_DB_LISTEN = 'ORBIT_DB_LISTEN';
// Database Events // Database Events
export const ORBIT_DATABASE_READY = 'ORBIT_DATABASE_READY'; export const ORBIT_DB_READY = 'ORBIT_DB_READY';
export const ORBIT_DATABASE_REPLICATING = 'ORBIT_DATABASE_REPLICATING'; export const ORBIT_DB_REPLICATING = 'ORBIT_DB_REPLICATING';
export const ORBIT_DATABASE_REPLICATED = 'ORBIT_DATABASE_REPLICATED'; export const ORBIT_DB_REPLICATED = 'ORBIT_DB_REPLICATED';
export const ORBIT_DATABASE_WRITE = 'ORBIT_DATABASE_WRITE'; export const ORBIT_DB_WRITE = 'ORBIT_DB_WRITE';
export function orbitInit (breeze, id) { export function orbitInit (breeze, id) {
return { 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 { return {
type: ORBIT_DATABASE_CREATING, type: ORBIT_DB_ADD,
orbit, dbInfo
db
} }
} }

20
src/orbit/orbitReducer.js
View File

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

63
src/orbit/orbitSaga.js
View File

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

1881
yarn.lock
View File

File diff suppressed because it is too large
Write Preview
Loading…
Cancel
Save