@zohodesk/platform-middleware/es/index.js

Generalized Contract for the events from Marketplace App, In-App widgets, CRM-Plus and EFC

import { validateConfig, zAppBroadcastEvent, zAppHookEvent, handleEvent, isEventNeededToBroadCast } from './utils';
import { loadSigmaAssests, loadInProductSDKAssets } from './loadAssets';
let configObj = {}; // let sampleConfig = {
//   "marketplace": {
//     "renderHandler": "<rednerHandler>",
//     "postAssetsFetch": "<postAssetsFetchHandler>",
//     "isDevMode": "<isDevModeHandler>",
//     "requestHandler": "<requestHandler>"
//   },
//   "locale": "<locale>",
//   "eventListeners": "<eventListenersHandlerObj> {DESK_EVENT: 'desk_event Handler', DESK_EVENT_V2: 'desk_event_v2 handler'}"
// }

function bindEventListeners(listnerObj) {
  let {
    listeners,
    dataList,
    getState,
    dispatch
  } = listnerObj;

  try {
    let listenerFunc = null,
        appEventListeners = {};
    Object.keys(listeners).forEach(listenerKey => {
      appEventListeners[listenerKey] = event => {
        listenerFunc = listeners[listenerKey];

        if (listenerFunc && typeof listenerFunc == 'function') {
          listenerFunc(handleEvent({
            event,
            getState,
            dispatch,
            dataList
          }));
        }
      };
    });

    if (typeof platformConfig !== 'undefined') {
      let existingListeners = platformConfig.eventHandlers || {};
      appEventListeners = Object.assign({}, existingListeners, appEventListeners);
    }

    return appEventListeners;
  } catch (error) {
    throw 'Listeners expect an JSON Object...';
  }
}

export const platformMiddleware = config => _ref => {
  let {
    dispatch,
    getState
  } = _ref;
  let {
    isConfigValid,
    errorMsg
  } = validateConfig(config);

  if (!isConfigValid) {
    throw errorMsg;
  }

  config.store = {
    dispatch,
    getState
  };
  configObj = config;
  window.platformConfig = {
    overrideInvokeMethodToCommonPattern: config.overrideInvokeMethodToCommonPattern,
    eventListenerName: config.eventListenerName || 'DESK_EVENT',
    eventHandlers: bindEventListeners({
      listeners: config.eventListeners,
      dispatch,
      getState,
      dataList: config.dataList
    })
  };

  if (config.featureFlags.isMarketplaceNeeded) {
    loadSigmaAssests(() => {
      if (typeof ZApp !== 'undefined') {
        config.marketplace.postAssestsFetch({
          dispatch,
          getState
        });
        /* Bootstraping the ZApp Framework */

        ZApp.Bootstrap({
          RenderHandlers: config.marketplace.renderHandler(dispatch, getState),
          isDevMode: config.marketplace.isDevMode(),
          EventListeners: bindEventListeners({
            listeners: config.eventListeners,
            dispatch,
            getState,
            dataList: config.dataList
          }),
          defaultLocale: config.locale || 'en',
          RequestHandler: (event, promise) => {
            return config.marketplace.requestHandler(handleEvent({
              event,
              getState,
              dispatch,
              promise
            }));
          }
        });
      }
    });
  }

  loadInProductSDKAssets({
    globalNameSpace: config.globalNameSpace,
    cb: function () {
      config.postProductSDKAssetsFetch();
    }
  });
  return next => action => {
    if (action.type === config.renderWidgetActionConstant) {
      let widgets = Array.isArray(action.data) ? action.data : [action.data];
      ZApp.RenderWidgets(widgets);
    }

    const eventList = config.events || {};
    let event = eventList[action.type];
    let hook = action.types && eventList[action.types[0]];
    /* Added for the URL CHANGE action gets dispatched twice */

    let isValidEvent = true;

    if (event && event.filter) {
      isValidEvent = event.filter(action);
    }

    if (isValidEvent && event && event.type === 'event' && isEventNeededToBroadCast(event)) {
      let prevState = getState();

      let getPrevState = () => {
        return prevState;
      };

      let nextAction = next(action);

      if (config.isPromiseBasedAction) {
        nextAction.then(() => {
          zAppBroadcastEvent({
            event,
            getState,
            dispatch,
            action,
            getPrevState
          });
        }).catch(err => {
          //Console.log -> Tarcking Error for future purpose.
          console.log(err);
        });
      } else {
        zAppBroadcastEvent({
          event,
          getState,
          dispatch,
          action,
          getPrevState
        });
      }

      return nextAction;
    } else if (hook && hook.type === 'hook' && isEventNeededToBroadCast(hook)) {
      return zAppHookEvent({
        hook,
        getState,
        dispatch,
        action,
        notifyHandler: data => {
          data = Object.assign(data, {
            dispatch,
            getState
          });
          config.marketplace.notifyHandler(data);
        }
      }).then(res => {
        return next(action);
      });
    } else {
      return next(action);
    }
  };
};