@zohodesk/platform-middleware/src/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) => ({ dispatch, getState }) => {
  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);
    }
  }
}