initial commit

4 files changed, 284 insertions, 0 deletions

diff --git a/src/stores/lib/CachedRequest.js b/src/stores/lib/CachedRequest.js
new file mode 100644
index 000000000..c0c3d40a1
--- /dev/null
+++ b/src/stores/lib/CachedRequest.js
@@ -0,0 +1,106 @@
+// @flow
+import { action } from 'mobx';
+import { isEqual, remove } from 'lodash';
+import Request from './Request';
+
+export default class CachedRequest extends Request {
+  _apiCalls = [];
+  _isInvalidated = true;
+
+  execute(...callArgs) {
+    // Do not continue if this request is already loading
+    if (this._isWaitingForResponse) return this;
+
+    // Very simple caching strategy -> only continue if the call / args changed
+    // or the request was invalidated manually from outside
+    const existingApiCall = this._findApiCall(callArgs);
+
+    // Invalidate if new or different api call will be done
+    if (existingApiCall && existingApiCall !== this._currentApiCall) {
+      this._isInvalidated = true;
+      this._currentApiCall = existingApiCall;
+    } else if (!existingApiCall) {
+      this._isInvalidated = true;
+      this._currentApiCall = this._addApiCall(callArgs);
+    }
+
+    // Do not continue if this request is not invalidated (see above)
+    if (!this._isInvalidated) return this;
+
+    // This timeout is necessary to avoid warnings from mobx
+    // regarding triggering actions as side-effect of getters
+    setTimeout(action(() => {
+      this.isExecuting = true;
+      // Apply the previous result from this call immediately (cached)
+      if (existingApiCall) {
+        this.result = existingApiCall.result;
+      }
+    }), 0);
+
+    // Issue api call & save it as promise that is handled to update the results of the operation
+    this._promise = new Promise((resolve, reject) => {
+      this._api[this._method](...callArgs)
+        .then((result) => {
+          setTimeout(action(() => {
+            this.result = result;
+            if (this._currentApiCall) this._currentApiCall.result = result;
+            this.isExecuting = false;
+            this.isError = false;
+            this.wasExecuted = true;
+            this._isInvalidated = false;
+            this._isWaitingForResponse = false;
+            this._triggerHooks();
+            resolve(result);
+          }), 1);
+          return result;
+        })
+        .catch(action((error) => {
+          setTimeout(action(() => {
+            this.error = error;
+            this.isExecuting = false;
+            this.isError = true;
+            this.wasExecuted = true;
+            this._isWaitingForResponse = false;
+            this._triggerHooks();
+            reject(error);
+          }), 1);
+        }));
+    });
+
+    this._isWaitingForResponse = true;
+    return this;
+  }
+
+  invalidate(options = { immediately: false }) {
+    this._isInvalidated = true;
+    if (options.immediately && this._currentApiCall) {
+      return this.execute(...this._currentApiCall.args);
+    }
+    return this;
+  }
+
+  patch(modify) {
+    return new Promise((resolve) => {
+      setTimeout(action(() => {
+        const override = modify(this.result);
+        if (override !== undefined) this.result = override;
+        if (this._currentApiCall) this._currentApiCall.result = this.result;
+        resolve(this);
+      }), 0);
+    });
+  }
+
+  removeCacheForCallWith(...args) {
+    remove(this._apiCalls, c => isEqual(c.args, args));
+  }
+
+  _addApiCall(args) {
+    const newCall = { args, result: null };
+    this._apiCalls.push(newCall);
+    return newCall;
+  }
+
+  _findApiCall(args) {
+    return this._apiCalls.find(c => isEqual(c.args, args));
+  }
+}
diff --git a/src/stores/lib/Reaction.js b/src/stores/lib/Reaction.js
new file mode 100644
index 000000000..e9bc26d81
--- /dev/null
+++ b/src/stores/lib/Reaction.js
@@ -0,0 +1,22 @@
+// @flow
+import { autorun } from 'mobx';
+
+export default class Reaction {
+  reaction;
+  hasBeenStarted;
+  dispose;
+
+  constructor(reaction) {
+    this.reaction = reaction;
+    this.hasBeenStarted = false;
+  }
+
+  start() {
+    this.dispose = autorun(() => this.reaction());
+    this.hasBeenStarted = true;
+  }
+
+  stop() {
+    if (this.hasBeenStarted) this.dispose();
+  }
+}
diff --git a/src/stores/lib/Request.js b/src/stores/lib/Request.js
new file mode 100644
index 000000000..4a6925cc5
--- /dev/null
+++ b/src/stores/lib/Request.js
@@ -0,0 +1,112 @@
+import { observable, action, computed } from 'mobx';
+import { isEqual } from 'lodash/fp';
+
+export default class Request {
+  static _hooks = [];
+
+  static registerHook(hook) {
+    Request._hooks.push(hook);
+  }
+
+  @observable result = null;
+  @observable error = null;
+  @observable isExecuting = false;
+  @observable isError = false;
+  @observable wasExecuted = false;
+
+  _promise = Promise;
+  _api = {};
+  _method = '';
+  _isWaitingForResponse = false;
+  _currentApiCall = null;
+
+  constructor(api, method) {
+    this._api = api;
+    this._method = method;
+  }
+
+  execute(...callArgs) {
+    // Do not continue if this request is already loading
+    if (this._isWaitingForResponse) return this;
+
+    if (!this._api[this._method]) {
+      throw new Error(`Missing method <${this._method}> on api object:`, this._api);
+    }
+
+    // This timeout is necessary to avoid warnings from mobx
+    // regarding triggering actions as side-effect of getters
+    setTimeout(action(() => {
+      this.isExecuting = true;
+    }), 0);
+
+    // Issue api call & save it as promise that is handled to update the results of the operation
+    this._promise = new Promise((resolve, reject) => {
+      this._api[this._method](...callArgs)
+        .then((result) => {
+          setTimeout(action(() => {
+            this.result = result;
+            if (this._currentApiCall) this._currentApiCall.result = result;
+            this.isExecuting = false;
+            this.isError = false;
+            this.wasExecuted = true;
+            this._isWaitingForResponse = false;
+            this._triggerHooks();
+            resolve(result);
+          }), 1);
+          return result;
+        })
+        .catch(action((error) => {
+          setTimeout(action(() => {
+            this.error = error;
+            this.isExecuting = false;
+            this.isError = true;
+            this.wasExecuted = true;
+            this._isWaitingForResponse = false;
+            this._triggerHooks();
+            reject(error);
+          }), 1);
+        }));
+    });
+
+    this._isWaitingForResponse = true;
+    this._currentApiCall = { args: callArgs, result: null };
+    return this;
+  }
+
+  reload() {
+    return this.execute(...this._currentApiCall.args);
+  }
+
+  isExecutingWithArgs(...args) {
+    return this.isExecuting && this._currentApiCall && isEqual(this._currentApiCall.args, args);
+  }
+
+  @computed get isExecutingFirstTime() {
+    return !this.wasExecuted && this.isExecuting;
+  }
+
+  then(...args) {
+    if (!this._promise) throw new Error('You have to call Request::execute before you can access it as promise');
+    return this._promise.then(...args);
+  }
+
+  catch(...args) {
+    if (!this._promise) throw new Error('You have to call Request::execute before you can access it as promise');
+    return this._promise.catch(...args);
+  }
+
+  _triggerHooks() {
+    Request._hooks.forEach(hook => hook(this));
+  }
+
+  reset() {
+    this.result = null;
+    this.isExecuting = false;
+    this.isError = false;
+    this.wasExecuted = false;
+    this._isWaitingForResponse = false;
+    this._promise = Promise;
+
+    return this;
+  }
+}
diff --git a/src/stores/lib/Store.js b/src/stores/lib/Store.js
new file mode 100644
index 000000000..873da7b37
--- /dev/null
+++ b/src/stores/lib/Store.js
@@ -0,0 +1,44 @@
+import { computed, observable } from 'mobx';
+import Reaction from './Reaction';
+
+export default class Store {
+  stores = {};
+  api = {};
+  actions = {};
+
+  _reactions = [];
+
+  // status implementation
+  @observable _status = null;
+  @computed get actionStatus() {
+    return this._status || [];
+  }
+  set actionStatus(status) {
+    this._status = status;
+  }
+
+  constructor(stores, api, actions) {
+    this.stores = stores;
+    this.api = api;
+    this.actions = actions;
+  }
+
+  registerReactions(reactions) {
+    reactions.forEach(reaction => this._reactions.push(new Reaction(reaction)));
+  }
+
+  setup() {}
+
+  initialize() {
+    this.setup();
+    this._reactions.forEach(reaction => reaction.start());
+  }
+
+  teardown() {
+    this._reactions.forEach(reaction => reaction.stop());
+  }
+
+  resetStatus() {
+    this._status = null;
+  }
+}