Issue #14 - Replace db transaction used when saving flattrs with a redux saga

src/lib/background/database/flattrs/save.js

@@ -0,0 +1,40 @@
+"use strict";
+
+const {Date} = require("global/window");
+
+const {db} = require("./index.js");
+
+function* save({entity, tabId, title, type, url})
+{
+  let {flattrs} = db;
+
+  if (url)
+  {
+    flattrs = flattrs.where("url").equals(url);
+  }
+  else
+  {
+    flattrs = flattrs.where("entity").equals(entity)
+        .and((entry) => entry.url == url);
+  }
+
+  let entry = yield flattrs.first();
+  if (!entry)
+  {
+    entry = {
+      entity, title, url,
+      timestamps: [Date.now()]
+    };
+
+    yield db.flattrs.add(entry);
+  }
+  else
+  {
+    entry.timestamps.push(Date.now());
+
+    yield db.flattrs.modify(entry);
+  }
+
+  return entry;
+}
+exports.save = save;

src/lib/background/flattrManager.js

@@ -1,46 +1,15 @@
 "use strict";
 
-const {Date} = require("global/window");
-
 const {emit} = require("../common/events");
 const {db} = require("./database/flattrs");
-const {sendFlattrs} = require("./state/actions/flattrs");
+const {saveFlattrs} = require("./state/actions/flattrs");
 const {store} = require("./state");
 
 function submit({entity, tabId, title, type, url})
 {
-  return db.transaction("rw", db.flattrs, function*()
-  {
-    let {flattrs} = db;
-    if (url)
-    {
-      flattrs = flattrs.where("url").equals(url);
-    }
-    else
-    {
-      flattrs = flattrs.where("entity").equals(entity)
-          .and((entry) => entry.url == url);
-    }
-    let entry = yield flattrs.first();
-    if (!entry)
-    {
-      entry = {
-        entity, title, url,
-        timestamps: []
-      };
-    }
-    entry.timestamps.push(Date.now());
-
-    yield db.flattrs.put(entry);
-
-    return entry;
-  })
-  .then((entry) =>
-  {
-    emit("flattr-added", {flattr: entry, tabId, type});
-    store.dispatch(sendFlattrs({flattrs: [entry]}));
-    return entry;
-  });
+  store.dispatch(saveFlattrs({
+    flattrs: [{entity, tabId, title, type, url}]
+  }));
 }
 exports.submit = submit;
 

src/lib/background/history/task.js

@@ -20,16 +20,16 @@ const settingName = "history.lastProcessing";
 
 function submitFlattrEntities(flattrEntities)
 {
-  return flattrEntities.map((entity) =>
+  for (let entity of flattrEntities)
   {
-    return submit({
+    submit({
       entity,
       tabId: null,
       title: entity,
       type: "visit",
       url: `http://${entity}/`
     });
-  });
+  }
 }
 
 function startProcessing(lastProcessing)

src/lib/background/session/storage.js

@@ -39,7 +39,7 @@ function addAttention(tabId, url, addedAttention, isManual)
 
         if (addedAttention >= getRemainingAttention(entity, oldAttention))
         {
-          yield flattrManager.submit({
+          flattrManager.submit({
             entity, tabId, url,
             title: page.title,
             type: "attention"

src/lib/background/state/actions/flattrs.js

@@ -1,9 +1,15 @@
 "use strict";
 
 const {
+  SAVE_FLATTRS,
   SUBMIT_FLATTRS
 } = require("../types/flattrs");
 
+exports.saveFlattrs = ({flattrs}) =>
+{
+  return {type: SAVE_FLATTRS, flattrs};
+};
+
 exports.sendFlattrs = ({flattrs}) =>
 {
   return {type: SUBMIT_FLATTRS, flattrs};

src/lib/background/state/reducers/flattrs.js

@@ -1,6 +1,9 @@
 "use strict";
 
 const {
+  SAVE_FLATTRS,
+  SAVE_FLATTRS_MERGE_PENDING,
+  SAVE_FLATTRS_SUCCESS,
   SUBMIT_FLATTRS,
   SUBMIT_FLATTRS_MERGE_PENDING,
   SUBMIT_FLATTRS_SUCCESS,
@@ -10,36 +13,67 @@ const {
 const {filterFlattrsForURLs} = require("../filters/flattrs");
 
 const getFlattrsInitialState = () => ({
-  submitting: [], pending: []
+  save: {saving: [], pending: []},
+  submit: {submitting: [], pending: []}
 });
 
+let validFlattrs = (action) => (
+    Array.isArray(action.flattrs) && action.flattrs.length > 0);
+
 const flattrsReducer = (state = getFlattrsInitialState(), action) =>
 {
-  let {submitting, pending} = state;
-  let diff = {};
+  let newState = {};
+  newState.save = Object.assign({}, state.save);
+  newState.submit = Object.assign({}, state.submit);
 
   switch (action.type)
   {
-    case SUBMIT_FLATTRS_MERGE_PENDING:
-      diff = {pending: [], submitting: submitting.concat(pending)};
+    case SAVE_FLATTRS:
+      if (!validFlattrs(action))
+      {
+        break;
+      }
+      newState.save.pending = state.save.pending.concat(action.flattrs);
+      break;
+    case SAVE_FLATTRS_MERGE_PENDING:
+      newState.save.pending = [];
+      newState.save.saving = state.save.saving.concat(state.save.pending);
+      break;
+    case SAVE_FLATTRS_SUCCESS:
+      newState.save.saving = [];
       break;
     case SUBMIT_FLATTRS:
-      if (!Array.isArray(action.flattrs) || action.flattrs.length < 1)
+      if (!validFlattrs(action))
       {
         break;
       }
-      diff.pending = pending.concat(filterFlattrsForURLs(action.flattrs));
+      newState.submit.pending =
+          state.submit.pending.concat(filterFlattrsForURLs(action.flattrs));
+      break;
+    case SUBMIT_FLATTRS_MERGE_PENDING:
+      newState.submit.pending = [];
+      newState.submit.submitting =
+          state.submit.submitting.concat(state.submit.pending);
       break;
     case SUBMIT_FLATTRS_FAILURE:
       // we gave up trying to send flattrs to server, so stick the failed
       // flattrs back in to the pending queue for the next event
-      diff.pending = pending.concat(submitting);
+      newState.submit.pending =
+          state.submit.pending.concat(state.submit.submitting);
       // fall through
     case SUBMIT_FLATTRS_SUCCESS:
-      diff.submitting = [];
+      newState.submit.submitting = [];
       break;
   }
 
-  return Object.assign({}, state, diff);
+  return newState;
 };
 exports.flattrs = flattrsReducer;
+
+const getFlattrs = (state) => ((state || {}).flattrs || {});
+
+const getFlattrsToSave = (state) => (getFlattrs(state).save || {});
+exports.getFlattrsToSave = getFlattrsToSave;
+
+const getFlattrsToSubmit = (state) => (getFlattrs(state).submit || {});
+exports.getFlattrsToSubmit = getFlattrsToSubmit;

src/lib/background/state/sagas/index.js

@@ -2,12 +2,14 @@
 
 const {fork} = require("redux-saga/effects");
 const {watchForFailuresAndLogError} = require("./failureLogger");
+const {watchForSaveFlattrs} = require("./saveFlattrs");
 const {watchForSubmitFlattrs} = require("./submitFlattrs");
 const {watchForNewVisits} = require("./saveVisitTimestamps");
 
 let sagas = [
   watchForFailuresAndLogError.bind(null, {}),
   watchForNewVisits,
+  watchForSaveFlattrs,
   watchForSubmitFlattrs
 ];
 

src/lib/background/state/sagas/saveFlattrs.js

@@ -0,0 +1,58 @@
+"use strict";
+
+const {buffers} = require("redux-saga");
+const {
+  actionChannel, call, put, select, take
+} = require("redux-saga/effects");
+
+const {
+  SAVE_FLATTRS,
+  SAVE_FLATTRS_MERGE_PENDING,
+  SAVE_FLATTRS_SUCCESS,
+  SUBMIT_FLATTRS
+} = require("../types/flattrs");
+const {getFlattrsToSave} = require("../reducers/flattrs");
+const {save} = require("../../database/flattrs/save");
+const {emit} = require("../../../common/events");
+
+function* saveFlattrs()
+{
+  yield put({type: SAVE_FLATTRS_MERGE_PENDING});
+
+  let {saving} = yield select(getFlattrsToSave);
+
+  for (let {entity, tabId, title, type, url} of saving)
+  {
+    let entry = yield call(save, {entity, tabId, title, type, url});
+
+    yield call(emit, "flattr-added", {flattr: entry, tabId, type});
+
+    // we don't want to wait for submission to complete here
+    yield call(put, {type: SUBMIT_FLATTRS, flattrs: [entry]});
+  }
+
+  yield put({type: SAVE_FLATTRS_SUCCESS});
+}
+
+function* watchForSaveFlattrs()
+{
+  const buffer = yield call(buffers.dropping, 1);
+
+  const saveFlattrsChan = yield actionChannel(SAVE_FLATTRS, buffer);
+
+  while (true)
+  {
+    yield take(saveFlattrsChan);
+
+    const {pending, saving} = yield select(getFlattrsToSave);
+
+    // it's possible that a previous handler already submit the flattrs
+    if (pending.length < 1 && saving.length < 1)
+    {
+      continue;
+    }
+
+    yield call(saveFlattrs, {});
+  }
+}
+exports.watchForSaveFlattrs = watchForSaveFlattrs;

src/lib/background/state/sagas/submitFlattrs.js

@@ -12,15 +12,12 @@ const {
   SUBMIT_FLATTRS_SUCCESS,
   SUBMIT_FLATTRS_FAILURE
 } = require("../types/flattrs");
-
+const {getFlattrsToSubmit} = require("../reducers/flattrs");
 const {API_RETRY_DELAY_MS} = require("../../../common/constants");
 const {sendFlattrs} = require("../../server/api");
 
 const retryStatus = new Set([0, 408, 409, 500, 502, 503, 504, 525, 599]);
 
-const getFlattrs = (state) => (state || {}).flattrs || {};
-exports.getFlattrs = getFlattrs;
-
 function* submitFlattrs({retryDelays = API_RETRY_DELAY_MS})
 {
   let retryCount = retryDelays.length;
@@ -30,7 +27,7 @@ function* submitFlattrs({retryDelays = API_RETRY_DELAY_MS})
     // submission
     yield put({type: SUBMIT_FLATTRS_MERGE_PENDING});
 
-    const {submitting: flattrs} = yield select(getFlattrs);
+    const {submitting: flattrs} = yield select(getFlattrsToSubmit);
 
     if (flattrs.length < 1)
     {
@@ -88,7 +85,7 @@ function* watchForSubmitFlattrs()
   {
     yield take(submitFlattrsChan);
 
-    const {pending, submitting} = yield select(getFlattrs);
+    const {pending, submitting} = yield select(getFlattrsToSubmit);
 
     // it's possible that a previous handler already submit the flattrs
     if (pending.length < 1 && submitting.length < 1)

src/lib/background/state/types/flattrs.js

@@ -1,5 +1,8 @@
 "use strict";
 
+exports.SAVE_FLATTRS = "DB:SAVE_FLATTRS";
+exports.SAVE_FLATTRS_MERGE_PENDING = "DB:SAVE_FLATTRS_MERGE_PENDING";
+exports.SAVE_FLATTRS_SUCCESS = "DB:SAVE_FLATTRS_SUCCESS";
 exports.SUBMIT_FLATTRS = "API:SUBMIT_FLATTRS";
 exports.SUBMIT_FLATTRS_MERGE_PENDING = "API:SUBMIT_FLATTRS_MERGE_PENDING";
 exports.SUBMIT_FLATTRS_SUCCESS = "API:SUBMIT_FLATTRS_SUCCESS";