@olea-bps/base 1.0.0

package/libraries/redux-offline/src/actions.js

@@ -0,0 +1,36 @@
+import {
+  OFFLINE_STATUS_CHANGED,
+  OFFLINE_SCHEDULE_RETRY,
+  OFFLINE_COMPLETE_RETRY,
+  OFFLINE_BUSY
+} from './constants';
+
+export const networkStatusChanged = params => {
+  let payload;
+  if (typeof params === 'object') {
+    payload = params;
+  } else {
+    payload = { online: params };
+  }
+  return {
+    type: OFFLINE_STATUS_CHANGED,
+    payload
+  };
+};
+
+export const scheduleRetry = (delay = 0) => ({
+  type: OFFLINE_SCHEDULE_RETRY,
+  payload: {
+    delay
+  }
+});
+
+export const completeRetry = action => ({
+  type: OFFLINE_COMPLETE_RETRY,
+  payload: action
+});
+
+export const busy = isBusy => ({
+  type: OFFLINE_BUSY,
+  payload: { busy: isBusy }
+});

package/libraries/redux-offline/src/config.js

@@ -0,0 +1,9 @@
+// @flow
+/* global $Shape */
+import type { Config } from './types';
+import defaults from './defaults';
+
+export const applyDefaults = (config: $Shape<Config> = {}): Config => ({
+  ...defaults,
+  ...config
+});

package/libraries/redux-offline/src/constants.js

@@ -0,0 +1,18 @@
+// @flow
+// Literal ACTION typing allows to ensure a stricter type than string
+
+export const OFFLINE_STATUS_CHANGED: 'Offline/STATUS_CHANGED' =
+  'Offline/STATUS_CHANGED';
+export const OFFLINE_SCHEDULE_RETRY: 'Offline/SCHEDULE_RETRY' =
+  'Offline/SCHEDULE_RETRY';
+export const OFFLINE_COMPLETE_RETRY: 'Offline/COMPLETE_RETRY' =
+  'Offline/COMPLETE_RETRY';
+export const OFFLINE_SEND: 'Offline/SEND' = 'Offline/SEND';
+export const OFFLINE_BUSY: 'Offline/BUSY' = 'Offline/BUSY';
+export const RESET_STATE: 'Offline/RESET_STATE' = 'Offline/RESET_STATE';
+export const PERSIST_REHYDRATE: 'persist/REHYDRATE' = 'persist/REHYDRATE';
+export const JS_ERROR: 'Offline/JS_ERROR' = 'Offline/JS_ERROR';
+export const DEFAULT_COMMIT: 'Offline/DEFAULT_COMMIT' =
+  'Offline/DEFAULT_COMMIT';
+export const DEFAULT_ROLLBACK: 'Offline/DEFAULT_ROLLBACK' =
+  'Offline/DEFAULT_ROLLBACK';

package/libraries/redux-offline/src/defaults/defaultCommit.js

@@ -0,0 +1,7 @@
+import { DEFAULT_COMMIT } from '../constants';
+
+const defaultCommit = {
+  type: DEFAULT_COMMIT
+};
+
+export default defaultCommit;

package/libraries/redux-offline/src/defaults/defaultRollback.js

@@ -0,0 +1,7 @@
+import { DEFAULT_ROLLBACK } from '../constants';
+
+const defaultRollback = {
+  type: DEFAULT_ROLLBACK
+};
+
+export default defaultRollback;

package/libraries/redux-offline/src/defaults/detectNetwork.js

@@ -0,0 +1,16 @@
+const handle = (callback, online) => {
+  // NetInfo is not supported in browsers, hence we only pass online status
+  if (window.requestAnimationFrame) {
+    window.requestAnimationFrame(() => callback({ online }));
+  } else {
+    setTimeout(() => callback({ online }), 0);
+  }
+};
+
+export default callback => {
+  if (typeof window !== 'undefined' && window.addEventListener) {
+    window.addEventListener('online', () => handle(callback, true));
+    window.addEventListener('offline', () => handle(callback, false));
+    handle(callback, window.navigator.onLine);
+  }
+};

package/libraries/redux-offline/src/defaults/detectNetwork.native.js

@@ -0,0 +1,148 @@
+/* eslint no-underscore-dangle: 0 */
+import { AppState } from 'react-native'; // eslint-disable-line
+import NetInfo from '@react-native-community/netinfo'; // eslint-disable-line
+
+class DetectNetwork {
+  constructor(callback) {
+    this._reach = null;
+    this._isConnected = null;
+    this._isConnectionExpensive = null;
+    this._callback = callback;
+    this._shouldInitUpdateReach = true;
+
+    this._init();
+    this._addListeners();
+  }
+
+  /**
+   * Check props for changes
+   * @param {string} reach - connection reachability.
+   *     - Cross-platform: [none, wifi, cellular, unknown]
+   *     - Android: [bluetooth, ethernet, wimax]
+   * @returns {boolean} - Whether the connection reachability or the connection props have changed
+   * @private
+   */
+  _hasChanged = reach => {
+    if (this._reach !== reach) {
+      return true;
+    }
+    if (this._isConnected !== this._getConnection(reach)) {
+      return true;
+    }
+    return false;
+  };
+
+  /**
+   * Sets the connection reachability prop
+   * @param {string} reach - connection reachability.
+   *     - Cross-platform: [none, wifi, cellular, unknown]
+   *     - Android: [bluetooth, ethernet, wimax]
+   * @returns {void}
+   * @private
+   */
+  _setReach = reach => {
+    this._reach = reach;
+    this._isConnected = this._getConnection(reach);
+  };
+
+  /**
+   * Gets the isConnected prop depending on the connection reachability's value
+   * @param {string} reach - connection reachability.
+   *     - Cross-platform: [none, wifi, cellular, unknown]
+   *     - Android: [bluetooth, ethernet, wimax]
+   * @returns {void}
+   * @private
+   */
+  _getConnection = reach => reach !== 'none' && reach !== 'unknown';
+
+  /**
+   * Sets the isConnectionExpensive prop
+   * @returns {Promise.<void>} Resolves to true if connection is expensive,
+   * false if not, and null if not supported.
+   * @private
+   */
+  _setIsConnectionExpensive = async () => {
+    try {
+      const { details } = await NetInfo.fetch();
+      this._isConnectionExpensive = details.isConnectionExpensive;
+    } catch (err) {
+      // err means that isConnectionExpensive is not supported in iOS
+      this._isConnectionExpensive = null;
+    }
+  };
+
+  /**
+   * Sets the shouldInitUpdateReach flag
+   * @param {boolean} shouldUpdate - Whether the init method should update the reach prop
+   * @returns {void}
+   * @private
+   */
+  _setShouldInitUpdateReach = shouldUpdate => {
+    this._shouldInitUpdateReach = shouldUpdate;
+  };
+
+  /**
+   * Fetches and sets the connection reachability and the isConnected props,
+   * if neither of the AppState and NetInfo event listeners have been called
+   * @returns {Promise.<void>} Resolves when the props have been
+   * initialized and update.
+   * @private
+   */
+  _init = async () => {
+    const connectionInfo = await NetInfo.fetch();
+    if (this._shouldInitUpdateReach) {
+      this._update(connectionInfo.type);
+    }
+  };
+
+  /**
+   * Check changes on props and store and dispatch if neccesary
+   * @param {string} reach - connection reachability.
+   *     - Cross-platform: [none, wifi, cellular, unknown]
+   *     - Android: [bluetooth, ethernet, wimax]
+   * @returns {void}
+   * @private
+   */
+  _update = reach => {
+    if (this._hasChanged(reach)) {
+      this._setReach(reach);
+      this._dispatch();
+    }
+  };
+
+  /**
+   * Adds listeners for when connection reachability and app state changes to update props
+   * @returns {void}
+   * @private
+   */
+  _addListeners() {
+    NetInfo.addEventListener(connectionInfo => {
+      this._setShouldInitUpdateReach(false);
+      this._update(connectionInfo.type);
+    });
+    AppState.addEventListener('change', async () => {
+      this._setShouldInitUpdateReach(false);
+      const connectionInfo = await NetInfo.fetch();
+      this._update(connectionInfo.type);
+    });
+  }
+
+  /**
+   * Executes the given callback to update redux's store with the new internal props
+   * @returns {Promise.<void>} Resolves after fetching the isConnectionExpensive
+   * and dispatches actions
+   * @private
+   */
+  _dispatch = async () => {
+    await this._setIsConnectionExpensive();
+    this._callback({
+      online: this._isConnected,
+      netInfo: {
+        isConnectionExpensive: this._isConnectionExpensive,
+        reach: this._reach
+      }
+    });
+  };
+}
+
+export default callback => new DetectNetwork(callback);

package/libraries/redux-offline/src/defaults/discard.js

@@ -0,0 +1,19 @@
+// @flow
+
+import type { OfflineAction } from '../types';
+import { NetworkError } from './effect';
+
+export default (
+  error: typeof NetworkError,
+  action: OfflineAction,
+  _retries: number = 0 // eslint-disable-line no-unused-vars
+): boolean => {
+  // not a network error -> discard
+  if (!('status' in error)) {
+    return true;
+  }
+
+  // discard http 4xx errors
+  // $FlowFixMe
+  return error.status >= 400 && error.status < 500;
+};

package/libraries/redux-offline/src/defaults/effect.js

@@ -0,0 +1,86 @@
+// @flow
+
+import type { OfflineAction } from '../types';
+
+export function NetworkError(response: {} | string, status: number) {
+  this.name = 'NetworkError';
+  this.status = status;
+  this.response = response;
+}
+
+// $FlowFixMe
+NetworkError.prototype = Error.prototype;
+
+const tryParseJSON = (json: string): ?{} => {
+  if (!json) {
+    return null;
+  }
+  try {
+    return JSON.parse(json);
+  } catch (e) {
+    throw new Error(`Failed to parse unexpected JSON response: ${json}`);
+  }
+};
+
+const getResponseBody = (res: any): Promise<{} | string> => {
+  const contentType = res.headers.get('content-type') || false;
+  if (contentType && contentType.indexOf('json') >= 0) {
+    return res.text().then(tryParseJSON);
+  }
+  return res.text();
+};
+
+export const getHeaders = (headers: {
+  [string]: string
+}): { [string]: string } => {
+  const {
+    'Content-Type': contentTypeCapitalized,
+    'content-type': contentTypeLowerCase,
+    ...restOfHeaders
+  } = headers || {};
+  const contentType =
+    contentTypeCapitalized || contentTypeLowerCase || 'application/json';
+  return { ...restOfHeaders, 'content-type': contentType };
+};
+
+export const getFormData = (object: {}) => {
+  const formData = new FormData();
+  Object.keys(object).forEach(key => {
+    Object.keys(object[key]).forEach(innerObj => {
+      const newObj = object[key][innerObj];
+      formData.append(newObj[0], newObj[1]);
+    });
+  });
+
+  return formData;
+};
+
+// eslint-disable-next-line no-unused-vars
+export default (effect: any, _action: OfflineAction): Promise<any> => {
+  const { url, json, ...options } = effect;
+  const headers = getHeaders(options.headers);
+
+  if (
+    !(options.body instanceof FormData) &&
+    Object.prototype.hasOwnProperty.call(headers, 'content-type') &&
+    headers['content-type'].toLowerCase().includes('multipart/form-data')
+  ) {
+    options.body = getFormData(options.body);
+  }
+
+  if (json !== null && json !== undefined) {
+    try {
+      options.body = JSON.stringify(json);
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+  return fetch(url, { ...options, headers }).then(res => {
+    if (res.ok) {
+      return getResponseBody(res);
+    }
+    return getResponseBody(res).then(body => {
+      throw new NetworkError(body || '', res.status);
+    });
+  });
+};

package/libraries/redux-offline/src/defaults/index.js

@@ -0,0 +1,25 @@
+import persist from './persist';
+import detectNetwork from './detectNetwork';
+import effect from './effect';
+import retry from './retry';
+import discard from './discard';
+import defaultCommit from './defaultCommit';
+import defaultRollback from './defaultRollback';
+import persistAutoRehydrate from './persistAutoRehydrate';
+import offlineStateLens from './offlineStateLens';
+import queue from './queue';
+
+export default {
+  rehydrate: true, // backward compatibility, TODO remove in the next breaking change version
+  persist,
+  detectNetwork,
+  effect,
+  retry,
+  discard,
+  defaultCommit,
+  defaultRollback,
+  persistAutoRehydrate,
+  offlineStateLens,
+  queue,
+  returnPromises: false
+};

package/libraries/redux-offline/src/defaults/offlineStateLens.js

@@ -0,0 +1,11 @@
+// @flow
+export default (state: any) => {
+  const { offline, ...rest } = state;
+  return {
+    get: offline,
+    set: (offlineState: any) =>
+      typeof offlineState === 'undefined'
+        ? rest
+        : { offline: offlineState, ...rest }
+  };
+};

package/libraries/redux-offline/src/defaults/persist.js

@@ -0,0 +1,4 @@
+// flow
+import { persistStore } from 'redux-persist';
+
+export default persistStore;

package/libraries/redux-offline/src/defaults/persist.native.js

@@ -0,0 +1,9 @@
+// @flow
+// $FlowIgnore
+import { persistStore } from 'redux-persist';
+// $FlowIgnore
+import AsyncStorage from '@react-native-async-storage/async-storage';
+
+export default (store: any, options: {}, callback: any) =>
+  // $FlowFixMe
+  persistStore(store, callback);

package/libraries/redux-offline/src/defaults/persistAutoRehydrate.js

@@ -0,0 +1,4 @@
+// @flow
+import { autoRehydrate } from 'redux-persist';
+
+export default autoRehydrate;

package/libraries/redux-offline/src/defaults/queue.js

@@ -0,0 +1,20 @@
+/* eslint-disable no-unused-vars */
+
+function enqueue(array, item, context) {
+  return [...array, item];
+}
+
+function dequeue(array, item, context) {
+  const [, ...rest] = array;
+  return rest;
+}
+
+function peek(array, item, context) {
+  return array[0];
+}
+
+export default {
+  enqueue,
+  dequeue,
+  peek
+};

package/libraries/redux-offline/src/defaults/retry.js

@@ -0,0 +1,18 @@
+// @flow
+import type { OfflineAction } from '../types';
+
+const decaySchedule = [
+  1000, // After 1 seconds
+  1000 * 5, // After 5 seconds
+  1000 * 15, // After 15 seconds
+  1000 * 30, // After 30 seconds
+  1000 * 60, // After 1 minute
+  1000 * 60 * 3, // After 3 minutes
+  1000 * 60 * 5, // After 5 minutes
+  1000 * 60 * 10, // After 10 minutes
+  1000 * 60 * 30, // After 30 minutes
+  1000 * 60 * 60 // After 1 hour
+];
+
+export default (action: OfflineAction, retries: number): ?number =>
+  decaySchedule[retries] || null;

package/libraries/redux-offline/src/index.js

@@ -0,0 +1,138 @@
+// @flow
+/* global $Shape */
+import { applyMiddleware, compose } from 'redux';
+import type { Config } from './types';
+import { createOfflineMiddleware } from './middleware';
+import { enhanceReducer } from './updater';
+import { applyDefaults } from './config';
+import { networkStatusChanged } from './actions';
+import offlineActionTracker from './offlineActionTracker';
+
+// @TODO: Take createStore as config?
+const warnIfNotReduxAction = (config: $Shape<Config>, key: string) => {
+  const maybeAction = config[key];
+
+  const isNotReduxAction =
+    maybeAction === null ||
+    typeof maybeAction !== 'object' ||
+    typeof maybeAction.type !== 'string' ||
+    maybeAction.type === '';
+
+  if (isNotReduxAction && console.warn) {
+    const msg =
+      `${key} must be a proper redux action, ` +
+      `i.e. it must be an object and have a non-empty string type. ` +
+      `Instead you provided: ${JSON.stringify(maybeAction, null, 2)}`;
+    console.warn(msg);
+  }
+};
+
+export const offline = (userConfig: $Shape<Config> = {}) => (
+  createStore: any
+) => (reducer: any, preloadedState: any, enhancer: any = x => x) => {
+  const config = applyDefaults(userConfig);
+
+  warnIfNotReduxAction(config, 'defaultCommit');
+  warnIfNotReduxAction(config, 'defaultRollback');
+
+  // toggle experimental returned promises
+  config.offlineActionTracker = config.returnPromises
+    ? offlineActionTracker.withPromises
+    : offlineActionTracker.withoutPromises;
+  delete config.returnPromises;
+
+  // wraps userland reducer with a top-level
+  // reducer that handles offline state updating
+  const offlineReducer = enhanceReducer(reducer, config);
+
+  // $FlowFixMe
+  const offlineMiddleware = applyMiddleware(createOfflineMiddleware(config));
+
+  // create autoRehydrate enhancer if required
+  const offlineEnhancer =
+    config.persist && config.rehydrate && config.persistAutoRehydrate
+      ? compose(offlineMiddleware, config.persistAutoRehydrate())
+      : offlineMiddleware;
+
+  // create store
+  const store = offlineEnhancer(createStore)(
+    offlineReducer,
+    preloadedState,
+    enhancer
+  );
+
+  const baseReplaceReducer = store.replaceReducer.bind(store);
+  // $FlowFixMe
+  store.replaceReducer = function replaceReducer(nextReducer) {
+    return baseReplaceReducer(enhanceReducer(nextReducer, config));
+  };
+
+  // launch store persistor
+  if (config.persist) {
+    config.persist(store, config.persistOptions, config.persistCallback);
+  }
+
+  // launch network detector
+  if (config.detectNetwork) {
+    config.detectNetwork(online => {
+      store.dispatch(networkStatusChanged(online));
+    });
+  }
+
+  return store;
+};
+
+export const createOffline = (userConfig: $Shape<Config> = {}) => {
+  const config = applyDefaults(userConfig);
+
+  // toggle experimental returned promises
+  config.offlineActionTracker = config.returnPromises
+    ? offlineActionTracker.withPromises
+    : offlineActionTracker.withoutPromises;
+  delete config.returnPromises;
+
+  warnIfNotReduxAction(config, 'defaultCommit');
+  warnIfNotReduxAction(config, 'defaultRollback');
+
+  const enhanceStore = (next: any) => (
+    reducer: any,
+    preloadedState: any,
+    enhancer: any
+  ) => {
+    // create autoRehydrate enhancer if required
+    const createStore =
+      config.persist && config.rehydrate && config.persistAutoRehydrate
+        ? config.persistAutoRehydrate()(next)
+        : next;
+
+    // create store
+    const store = createStore(reducer, preloadedState, enhancer);
+
+    const baseReplaceReducer = store.replaceReducer.bind(store);
+    store.replaceReducer = function replaceReducer(nextReducer) {
+      return baseReplaceReducer(enhanceReducer(nextReducer, config));
+    };
+
+    // launch store persistor
+    if (config.persist) {
+      config.persist(store, config.persistOptions, config.persistCallback);
+    }
+
+    // launch network detector
+    if (config.detectNetwork) {
+      config.detectNetwork(online => {
+        store.dispatch(networkStatusChanged(online));
+      });
+    }
+
+    return store;
+  };
+
+  return {
+    middleware: createOfflineMiddleware(config),
+    enhanceReducer(reducer: any) {
+      return enhanceReducer(reducer, config);
+    },
+    enhanceStore
+  };
+};

package/libraries/redux-offline/src/middleware.js

@@ -0,0 +1,52 @@
+// @flow
+
+import type { AppState, Config } from './types';
+import { OFFLINE_SEND, OFFLINE_SCHEDULE_RETRY } from './constants';
+import { completeRetry } from './actions';
+import send from './send';
+
+const after = (timeout = 0) =>
+  new Promise(resolve => setTimeout(resolve, timeout));
+
+export const createOfflineMiddleware = (config: Config) => (store: any) => (
+  next: any
+) => (action: any) => {
+  // allow other middleware to do their things
+  const result = next(action);
+  let promise;
+
+  // find any actions to send, if any
+  const state: AppState = store.getState();
+  const offline = config.offlineStateLens(state).get;
+  const context = { offline };
+  const offlineAction = config.queue.peek(offline.outbox, action, context);
+
+  // create promise to return on enqueue offline action
+  if (action.meta && action.meta.offline) {
+    const { registerAction } = config.offlineActionTracker;
+    promise = registerAction(offline.lastTransaction);
+  }
+
+  // if there are any actions in the queue that we are not
+  // yet processing, send those actions
+  if (
+    offlineAction &&
+    !offline.busy &&
+    !offline.retryScheduled &&
+    offline.online
+  ) {
+    send(offlineAction, store.dispatch, config, offline.retryCount);
+  }
+
+  if (action.type === OFFLINE_SCHEDULE_RETRY) {
+    after(action.payload.delay).then(() => {
+      store.dispatch(completeRetry(offlineAction));
+    });
+  }
+
+  if (action.type === OFFLINE_SEND && offlineAction && !offline.busy) {
+    send(offlineAction, store.dispatch, config, offline.retryCount);
+  }
+
+  return promise || result;
+};

package/libraries/redux-offline/src/offlineActionTracker.js

@@ -0,0 +1,40 @@
+const subscriptions = {};
+
+function registerAction(transaction) {
+  return new Promise((resolve, reject) => {
+    subscriptions[transaction] = { resolve, reject };
+  });
+}
+
+function resolveAction(transaction, value) {
+  const subscription = subscriptions[transaction];
+  if (subscription) {
+    subscription.resolve(value);
+    delete subscriptions[transaction];
+  }
+}
+
+function rejectAction(transaction, error) {
+  const subscription = subscriptions[transaction];
+  if (subscription) {
+    subscription.reject(error);
+    delete subscriptions[transaction];
+  }
+}
+
+const withPromises = {
+  registerAction,
+  resolveAction,
+  rejectAction
+};
+
+const withoutPromises = {
+  registerAction() {},
+  resolveAction() {},
+  rejectAction() {}
+};
+
+export default {
+  withPromises,
+  withoutPromises
+};