@olea-bps/base 1.0.0

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

@@ -0,0 +1,111 @@
+// @flow
+import { busy, scheduleRetry } from './actions';
+import { JS_ERROR } from './constants';
+import type {
+  Config,
+  OfflineAction,
+  ResultAction,
+  DefaultAction
+} from './types';
+
+type CompleteSuccessResult = {
+  success: true,
+  payload: {}
+};
+
+type CompleteFailResult = {
+  success: false,
+  payload?: Error
+};
+
+const complete = (
+  action: DefaultAction | ResultAction,
+  result: CompleteSuccessResult | CompleteFailResult,
+  offlineAction: OfflineAction,
+  config: Config
+): ResultAction => {
+  const { resolveAction, rejectAction } = config.offlineActionTracker;
+  if (result.success) {
+    resolveAction(offlineAction.meta.transaction, result.payload);
+  } else if (result.payload) {
+    rejectAction(offlineAction.meta.transaction, result.payload);
+  }
+  return (({
+    ...action,
+    payload: result.payload,
+    meta: { ...action.meta, success: result.success, completed: true }
+  }: any): ResultAction);
+};
+
+const handleJsError = (error: Error): ResultAction =>
+  (({
+    type: JS_ERROR,
+    meta: { error, success: false, completed: true }
+  }: any): ResultAction);
+
+const send = (
+  action: OfflineAction,
+  dispatch: any => any,
+  config: Config,
+  retries: number = 0
+) => {
+  const metadata = action.meta.offline;
+  dispatch(busy(true));
+  return config
+    .effect(metadata.effect, action)
+    .then(result => {
+      const commitAction =
+        metadata.commit ||
+        ({
+          ...config.defaultCommit,
+          meta: { ...config.defaultCommit.meta, offlineAction: action }
+        }: DefaultAction);
+      try {
+        return dispatch(
+          complete(
+            commitAction,
+            { success: true, payload: result },
+            action,
+            config
+          )
+        );
+      } catch (error) {
+        return dispatch(handleJsError(error));
+      }
+    })
+    .catch(async error => {
+      const rollbackAction =
+        metadata.rollback ||
+        ({
+          ...config.defaultRollback,
+          meta: { ...config.defaultRollback.meta, offlineAction: action }
+        }: DefaultAction);
+
+      // discard
+      let mustDiscard = true;
+      try {
+        mustDiscard = await config.discard(error, action, retries);
+      } catch (e) {
+        console.warn(e);
+      }
+
+      if (!mustDiscard) {
+        const delay = config.retry(action, retries);
+        if (delay != null) {
+          return dispatch(scheduleRetry(delay));
+        }
+      }
+
+      return dispatch(
+        complete(
+          rollbackAction,
+          { success: false, payload: error },
+          action,
+          config
+        )
+      );
+    })
+    .finally(() => dispatch(busy(false)));
+};
+
+export default send;

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

@@ -0,0 +1,127 @@
+// @flow
+import {
+  OFFLINE_STATUS_CHANGED,
+  OFFLINE_SCHEDULE_RETRY,
+  PERSIST_REHYDRATE
+} from './constants';
+
+export type ResultAction = {
+  type: string,
+  payload?: {},
+  meta: {
+    offline?: {},
+    success: boolean,
+    completed: boolean,
+    error?: Error
+  }
+};
+
+export type OfflineMetadata = {
+  effect: {},
+  commit?: ResultAction,
+  rollback?: ResultAction
+};
+
+// User passed action
+// it is impossible to use a type literal for it,
+// since it can be any user passed string
+export type OfflineAction = {
+  type: string,
+  payload?: any,
+  meta: {
+    transaction: number,
+    offline: OfflineMetadata
+  }
+};
+
+export type NetInfo = {
+  isConnectionExpensive: ?boolean,
+  reach: string
+};
+
+export type OfflineStatusChangeAction = {
+  type: typeof OFFLINE_STATUS_CHANGED,
+  payload: {
+    online: boolean,
+    netInfo?: NetInfo
+  },
+  meta: typeof undefined
+};
+
+export type OfflineScheduleRetryAction = {
+  type: typeof OFFLINE_SCHEDULE_RETRY
+};
+
+export type Outbox = Array<OfflineAction>;
+
+export type OfflineState = {
+  busy: boolean,
+  lastTransaction: number,
+  online: boolean,
+  outbox: Outbox,
+  netInfo?: NetInfo,
+  retryCount: number,
+  retryScheduled: boolean
+};
+
+export type PersistRehydrateAction = {
+  type: typeof PERSIST_REHYDRATE,
+  payload: {
+    offline: OfflineState
+  },
+  meta: typeof undefined
+};
+
+export type DefaultAction = {
+  type: string,
+  meta: {
+    offline: typeof undefined,
+    offlineAction: { type: string }
+  }
+};
+
+export type AppState = {
+  offline: OfflineState
+};
+
+type NetworkCallback = (result: boolean) => void;
+
+export type Config = {
+  detectNetwork: (callback: NetworkCallback) => void,
+  persist: (store: any, options: {}, callback: () => void) => any,
+  effect: (effect: any, action: OfflineAction) => Promise<*>,
+  retry: (action: OfflineAction, retries: number) => ?number,
+  discard: (error: any, action: OfflineAction, retries: number) => boolean,
+  persistOptions: {},
+  persistCallback: (callback: any) => any,
+  defaultCommit: DefaultAction,
+  defaultRollback: DefaultAction,
+  persistAutoRehydrate: (config: ?{}) => (next: any) => any,
+  offlineStateLens: (
+    state: any
+  ) => { get: OfflineState, set: (offlineState: ?OfflineState) => any },
+  queue: {
+    enqueue: (
+      array: Array<OfflineAction>,
+      item: OfflineAction,
+      context: { offline: OfflineState }
+    ) => Array<OfflineAction>,
+    dequeue: (
+      array: Array<OfflineAction>,
+      item: ResultAction,
+      context: { offline: OfflineState }
+    ) => Array<OfflineAction>,
+    peek: (
+      array: Array<OfflineAction>,
+      item: any,
+      context: { offline: OfflineState }
+    ) => OfflineAction
+  },
+  offlineActionTracker: {
+    registerAction: number => Promise<*> | (() => void),
+    resolveAction: (number, any) => void | (() => void),
+    rejectAction: (number, Error) => void | (() => void)
+  },
+  returnPromises?: boolean,
+  rehydrate?: boolean
+};

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

@@ -0,0 +1,141 @@
+// @flow
+/* global $Shape */
+
+import type {
+  OfflineStatusChangeAction,
+  OfflineScheduleRetryAction,
+  PersistRehydrateAction,
+  OfflineAction,
+  OfflineState,
+  ResultAction,
+  Config
+} from './types';
+import {
+  OFFLINE_STATUS_CHANGED,
+  OFFLINE_SCHEDULE_RETRY,
+  OFFLINE_COMPLETE_RETRY,
+  OFFLINE_BUSY,
+  RESET_STATE,
+  PERSIST_REHYDRATE
+} from './constants';
+
+export const initialState: OfflineState = {
+  busy: false,
+  lastTransaction: 0,
+  online: false,
+  outbox: [],
+  retryCount: 0,
+  retryScheduled: false,
+  netInfo: {
+    isConnectionExpensive: null,
+    reach: 'NONE'
+  }
+};
+
+type Dequeue = $PropertyType<$PropertyType<Config, 'queue'>, 'dequeue'>;
+type Enqueue = $PropertyType<$PropertyType<Config, 'queue'>, 'enqueue'>;
+
+export const buildOfflineUpdater = (dequeue: Dequeue, enqueue: Enqueue) =>
+  function offlineUpdater(
+    state: OfflineState = initialState,
+    action:
+      | OfflineStatusChangeAction
+      | OfflineScheduleRetryAction
+      | ResultAction
+      | PersistRehydrateAction
+  ): OfflineState {
+    // Update online/offline status
+    if (action.type === OFFLINE_STATUS_CHANGED && !action.meta) {
+      return {
+        ...state,
+        online: action.payload.online,
+        netInfo: action.payload.netInfo
+      };
+    }
+
+    if (action.type === PERSIST_REHYDRATE && action.payload) {
+      return {
+        ...state,
+        ...(action.payload.offline || {}),
+        online: state.online,
+        netInfo: state.netInfo,
+        retryScheduled: initialState.retryScheduled,
+        retryCount: initialState.retryCount,
+        busy: initialState.busy
+      };
+    }
+
+    if (action.type === OFFLINE_SCHEDULE_RETRY) {
+      return {
+        ...state,
+        retryScheduled: true,
+        retryCount: state.retryCount + 1
+      };
+    }
+
+    if (action.type === OFFLINE_COMPLETE_RETRY) {
+      return { ...state, retryScheduled: false };
+    }
+
+    if (
+      action.type === OFFLINE_BUSY &&
+      !action.meta &&
+      action.payload &&
+      typeof action.payload.busy === 'boolean'
+    ) {
+      return { ...state, busy: action.payload.busy };
+    }
+
+    // Add offline actions to queue
+    if (action.meta && action.meta.offline) {
+      const transaction = state.lastTransaction + 1;
+      const stamped = (({
+        ...action,
+        meta: { ...action.meta, transaction }
+      }: any): OfflineAction);
+      const offline = state;
+      return {
+        ...state,
+        lastTransaction: transaction,
+        outbox: enqueue(offline.outbox, stamped, { offline })
+      };
+    }
+
+    // Remove completed actions from queue (success or fail)
+    if (action.meta && action.meta.completed === true) {
+      const offline = state;
+      return {
+        ...state,
+        outbox: dequeue(offline.outbox, action, { offline }),
+        retryCount: 0
+      };
+    }
+
+    if (action.type === RESET_STATE) {
+      return {
+        ...initialState,
+        online: state.online,
+        netInfo: state.netInfo
+      };
+    }
+
+    return state;
+  };
+
+export const enhanceReducer = (reducer: any, config: $Shape<Config>) => {
+  const { dequeue, enqueue } = config.queue;
+  const offlineUpdater = buildOfflineUpdater(dequeue, enqueue);
+
+  return (state: any, action: any): any => {
+    let offlineState;
+    let restState;
+    if (typeof state !== 'undefined') {
+      offlineState = config.offlineStateLens(state).get;
+      restState = config.offlineStateLens(state).set();
+    }
+
+    return config
+      .offlineStateLens(reducer(restState, action))
+      .set(offlineUpdater(offlineState, action));
+  };
+};

package/libraries/redux-offline/typings.d.ts

@@ -0,0 +1,150 @@
+declare module '@olea-bps/redux-offline/lib/defaults' {
+  import { Config } from '@olea-bps/redux-offline/lib/types';
+
+  const config: Config;
+  export default config;
+}
+
+declare module '@olea-bps/redux-offline/lib/types' {
+  export interface ResultAction {
+    meta: {
+      completed: boolean;
+      success: boolean;
+    };
+    payload?: object;
+    type: string;
+  }
+
+  export interface OfflineMetadata {
+    commit?: ResultAction;
+    effect: object;
+    rollback?: ResultAction;
+  }
+
+  export interface OfflineAction {
+    meta: {
+      offline: OfflineMetadata;
+      transaction?: number;
+    };
+    payload?: object;
+    type: string;
+  }
+
+  export interface NetInfo {
+    isConnectionExpensive?: boolean;
+    reach: string;
+  }
+
+  export interface OfflineStatusChangeAction {
+    payload: {
+      netInfo?: NetInfo;
+      online: boolean;
+    };
+    type: string;
+  }
+
+  export interface OfflineScheduleRetryAction {
+    type: string;
+  }
+
+  export type Outbox = OfflineAction[];
+
+  export interface OfflineState {
+    busy: boolean;
+    lastTransaction: number;
+    netInfo?: NetInfo;
+    online: boolean;
+    outbox: Outbox;
+    retryCount: number;
+    retryScheduled: boolean;
+  }
+
+  export interface PersistRehydrateAction {
+    payload: {
+      offline: OfflineState;
+    };
+    type: string;
+  }
+
+  export interface AppState {
+    offline: OfflineState;
+  }
+
+  export type NetworkCallback = (result: boolean) => void;
+
+  export interface Config {
+    defaultCommit: { type: string };
+    defaultRollback: { type: string };
+    detectNetwork: (callback: NetworkCallback) => void;
+    discard: (error: any, action: OfflineAction, retries: number) => boolean;
+    effect: (effect: any, action: OfflineAction) => Promise<any>;
+    offlineStateLens: (
+      state: any,
+    ) => { get: OfflineState, set: (offlineState?: OfflineState) => any };
+    persist: (store: any) => any;
+    persistAutoRehydrate: (config?: { [key: string]: any }) => (next: any) => any;
+    persistCallback: (callback?: any) => any;
+    persistOptions: { [key: string]: any };
+    retry: (action: OfflineAction, retries: number) => number | void;
+    queue: {
+      enqueue: (
+        array: Array<OfflineAction>,
+        item: OfflineAction,
+        context: { offline: OfflineState }
+      ) => Array<OfflineAction>,
+      dequeue: (
+        array: Array<OfflineAction>,
+        item: ResultAction,
+        context: { offline: OfflineState }
+      ) => Array<OfflineAction>,
+      peek: (
+        array: Array<OfflineAction>,
+        item: any,
+        context: { offline: OfflineState }
+      ) => OfflineAction
+    };
+    offlineActionTracker: {
+      registerAction: (transaction: number) => Promise<any> | (() => void),
+      resolveAction: (transaction: number, value: any) => void | (() => void),
+      rejectAction: (transaction: number, error: Error) => void | (() => void)
+    };
+    returnPromises?: boolean;
+    rehydrate?: boolean;
+  }
+}
+
+declare module '@olea-bps/redux-offline/lib/constants' {
+  export const DEFAULT_ROLLBACK: string;
+  export const DEFAULT_COMMIT: string;
+  export const JS_ERROR: string;
+  export const PERSIST_REHYDRATE: string;
+  export const RESET_STATE: string;
+  export const OFFLINE_BUSY: string;
+  export const OFFLINE_SEND: string;
+  export const OFFLINE_COMPLETE_RETRY: string;
+  export const OFFLINE_SCHEDULE_RETRY: string;
+  export const OFFLINE_STATUS_CHANGED: string;
+}
+
+declare module '@olea-bps/redux-offline' {
+  import { createStore as createReduxStore, Store, StoreEnhancer, Dispatch, Middleware } from 'redux';
+
+  import { Config } from '@olea-bps/redux-offline/lib/types';
+
+  export const offline: (userConfig: Partial<Config>) => (createStore: typeof createReduxStore) =>
+    <T extends { [key: string]: any }>(
+      reducer: (state: T, action: any) => T,
+      preloadedState: T,
+      enhancer: StoreEnhancer<T>,
+    ) => Store<T>;
+
+  export const createOffline: (userConfig: Partial<Config>) => ({
+    enhanceReducer: (reducer: any) => (state: any, action: any) => any,
+    enhanceStore: (next: any) => <T extends { [key: string]: any }>(
+      reducer: (state: T, action: any) => T,
+      preloadedState: T,
+      enhancer: StoreEnhancer<T>,
+    ) => Store<T>,
+    middleware: Middleware
+  });
+}