hasura · 0x777 · Jul 8, 2019 · Apr 29, 2019 · Apr 29, 2019 · Apr 29, 2019
@@ -13,7 +13,7 @@ import {
 } from '../Add/addResolverReducer';
 
 import { VIEW_RESOLVER } from '../customActions';
-import ReloadMetadata from '../../Metadata/MetadataOptions/ReloadMetadata';
+import ReloadRemoteSchema from '../../Metadata/MetadataOptions/ReloadRemoteSchema';
 
 import { appPrefix } from '../constants';
 
@@ -117,6 +117,23 @@ class ViewStitchedSchema extends React.Component {
       </Tooltip>
     );
 
+    const showReloadRemoteSchema =
+      resolverName && resolverName.length > 0 ? (
+        <div className={styles.commonBtn + ' ' + styles.detailsRefreshButton}>
+          <span>
+            <ReloadRemoteSchema
+              {...this.props}
+              remoteSchemaName={resolverName}
+            />
+          </span>
+          <span>
+            <OverlayTrigger placement="right" overlay={refresh}>
+              <i className="fa fa-question-circle" aria-hidden="true" />
+            </OverlayTrigger>
+          </span>
+        </div>
+      ) : null;
+
     return (
       <div
         className={styles.view_stitch_schema_wrapper + ' ' + styles.addWrapper}
@@ -169,21 +186,7 @@ class ViewStitchedSchema extends React.Component {
               </tbody>
             </table>
           </div>
-          <div className={styles.commonBtn + ' ' + styles.detailsRefreshButton}>
-            <span>
-              <ReloadMetadata
-                {...this.props}
-                btnText={'Refresh schema'}
-                btnTextChanging={'Refreshing schema...'}
-                bsClass={styles.yellow_button}
-              />
-            </span>
-            <span>
-              <OverlayTrigger placement="right" overlay={refresh}>
-                <i className="fa fa-question-circle" aria-hidden="true" />
-              </OverlayTrigger>
-            </span>
-          </div>
+          {showReloadRemoteSchema}
         </div>
         <br />
         <br />

@@ -12,6 +12,7 @@ import { loadMigrationStatus } from '../../Main/Actions';
 import { handleMigrationErrors } from '../EventTrigger/EventActions';
 
 import { showSuccessNotification } from '../Common/Notification';
+import { filterInconsistentMetadataObjects } from '../Metadata/utils';
 
 /* Action constants */
 
@@ -20,6 +21,7 @@ const RESOLVERS_FETCH_SUCCESS = '@customResolver/RESOLVERS_FETCH_SUCCESS';
 const FILTER_RESOLVER = '@customResolver/FILTER_RESOLVER';
 const RESOLVERS_FETCH_FAIL = '@customResolver/RESOLVERS_FETCH_FAIL';
 const RESET = '@customResolver/RESET';
+const SET_CONSISTENT_RESOLVERS = '@customResolver/SET_CONSISTENT_RESOLVERS';
 
 const VIEW_RESOLVER = '@customResolver/VIEW_RESOLVER';
 
@@ -47,7 +49,21 @@ const fetchResolvers = () => {
     dispatch({ type: FETCH_RESOLVERS });
     return dispatch(requestAction(url, options)).then(
       data => {
-        dispatch({ type: RESOLVERS_FETCH_SUCCESS, data: data });
+        let consistentRemoteSchemas = data;
+        const { inconsistentObjects } = getState().metadata;
+
+        if (inconsistentObjects.length > 0) {
+          consistentRemoteSchemas = filterInconsistentMetadataObjects(
+            data,
+            inconsistentObjects,
+            'remote_schemas'
+          );
+        }
+
+        dispatch({
+          type: RESOLVERS_FETCH_SUCCESS,
+          data: consistentRemoteSchemas,
+        });
         return Promise.resolve();
       },
       error => {
@@ -59,6 +75,11 @@ const fetchResolvers = () => {
   };
 };
 
+const setConsistentRemoteSchemas = data => ({
+  type: SET_CONSISTENT_RESOLVERS,
+  data,
+});
+
 const listReducer = (state = listState, action) => {
   switch (action.type) {
     case FETCH_RESOLVERS:
@@ -97,6 +118,11 @@ const listReducer = (state = listState, action) => {
         ...state,
         viewResolver: action.data,
       };
+    case SET_CONSISTENT_RESOLVERS:
+      return {
+        ...state,
+        resolvers: action.data,
+      };
     default:
       return {
         ...state,
@@ -172,5 +198,11 @@ const makeRequest = (
 };
 /* */
 
-export { fetchResolvers, FILTER_RESOLVER, VIEW_RESOLVER, makeRequest };
+export {
+  fetchResolvers,
+  FILTER_RESOLVER,
+  VIEW_RESOLVER,
+  makeRequest,
+  setConsistentRemoteSchemas,
+};
 export default listReducer;
@@ -16,10 +16,8 @@ import {
 import dataHeaders from './Common/Headers';
 import { loadMigrationStatus } from '../../Main/Actions';
 import returnMigrateUrl from './Common/getMigrateUrl';
-import {
-  filterInconsistentMetadata,
-  loadInconsistentObjects,
-} from '../Metadata/Actions';
+import { loadInconsistentObjects } from '../Metadata/Actions';
+import { filterInconsistentMetadataObjects } from '../Metadata/utils';
 import globals from '../../../Globals';
 
 import {
@@ -193,7 +191,7 @@ const fetchTrackedFunctions = () => {
         const { inconsistentObjects } = getState().metadata;
 
         if (inconsistentObjects.length > 0) {
-          consistentFunctions = filterInconsistentMetadata(
+          consistentFunctions = filterInconsistentMetadataObjects(
             data,
             inconsistentObjects,
             'functions'
@@ -291,7 +289,7 @@ const loadSchema = configOptions => {
 
         let consistentSchemas;
         if (inconsistentObjects.length > 0) {
-          consistentSchemas = filterInconsistentMetadata(
+          consistentSchemas = filterInconsistentMetadataObjects(
             maybeInconsistentSchemas,
             inconsistentObjects,
             'tables'
@@ -384,7 +382,7 @@ const fetchFunctionInit = () => (dispatch, getState) => {
       let consistentFunctions = data[2];
       const { inconsistentObjects } = getState().metadata;
       if (inconsistentObjects.length > 0) {
-        consistentFunctions = filterInconsistentMetadata(
+        consistentFunctions = filterInconsistentMetadataObjects(
           consistentFunctions,
           inconsistentObjects,
           'functions'

@@ -14,10 +14,8 @@ import { loadMigrationStatus } from '../../Main/Actions';
 import returnMigrateUrl from './Common/getMigrateUrl';
 import globals from '../../../Globals';
 import push from './push';
-import {
-  filterInconsistentMetadata,
-  loadInconsistentObjects,
-} from '../Metadata/Actions';
+import { loadInconsistentObjects } from '../Metadata/Actions';
+import { filterInconsistentMetadataObjects } from '../Metadata/utils';
 import { replace } from 'react-router-redux';
 import { getEventTriggersQuery } from './utils';
 
@@ -73,7 +71,7 @@ const loadTriggers = triggerNames => (dispatch, getState) => {
       const { inconsistentObjects } = getState().metadata;
       let consistentTriggers;
       if (inconsistentObjects.length > 1) {
-        consistentTriggers = filterInconsistentMetadata(
+        consistentTriggers = filterInconsistentMetadataObjects(
           triggerData,
           inconsistentObjects,
           'events'

@@ -3,11 +3,13 @@ import { push } from 'react-router-redux';
 import globals from '../../../Globals';
 import endpoints from '../../../Endpoints';
 import defaultState from './State';
-import { filterSchema } from './utils';
+import { filterInconsistentMetadataObjects } from './utils';
+import { RELOAD_METADATA_API_CHANGE } from '../../../helpers/versionUtils';
 import {
   setConsistentSchema,
   setConsistentFunctions,
 } from '../Data/DataActions';
+import { setConsistentRemoteSchemas } from '../CustomResolver/customActions';
 import {
   showSuccessNotification,
   showErrorNotification,
@@ -37,6 +39,25 @@ const reloadCacheQuery = {
   args: {},
 };
 
+const reloadRemoteSchemaCacheQuery = remoteSchemaName => {
+  return {
+    type: 'reload_remote_schema',
+    args: {
+      name: remoteSchemaName,
+    },
+  };
+};
+
+const reloadRemoteSchemaCacheAndGetInconsistentObjectsQuery = remoteSchemaName => {
+  return {
+    type: 'bulk',
+    args: [
+      reloadRemoteSchemaCacheQuery(remoteSchemaName),
+      getInconsistentObjectsQuery,
+    ],
+  };
+};
+
 const reloadCacheAndGetInconsistentObjectsQuery = {
   type: 'bulk',
   args: [reloadCacheQuery, getInconsistentObjectsQuery],
@@ -47,17 +68,39 @@ const dropInconsistentObjectsQuery = {
   args: {},
 };
 
-export const filterInconsistentMetadata = (
-  metadata,
-  inconsistentObjects,
-  type
-) => {
-  let filtered = JSON.parse(JSON.stringify(metadata));
-  inconsistentObjects.forEach(object => {
-    const partiallyFiltered = filterSchema(filtered, object, type);
-    filtered = partiallyFiltered;
-  });
-  return filtered;
+const handleInconsistentObjects = inconsistentObjects => {
+  return (dispatch, getState) => {
+    const allSchemas = getState().tables.allSchemas;
+    const functions = getState().tables.trackedFunctions;
+    const remoteSchemas = getState().customResolverData.listData.resolvers;
+
+    dispatch({
+      type: LOAD_INCONSISTENT_OBJECTS,
+      data: inconsistentObjects,
+    });
+
+    if (inconsistentObjects.length > 0) {
+      const filteredSchema = filterInconsistentMetadataObjects(
+        allSchemas,
+        inconsistentObjects,
+        'tables'
+      );
+      const filteredFunctions = filterInconsistentMetadataObjects(
+        functions,
+        inconsistentObjects,
+        'functions'
+      );
+      const filteredRemoteSchemas = filterInconsistentMetadataObjects(
+        remoteSchemas,
+        inconsistentObjects,
+        'remote_schemas'
+      );
+
+      dispatch(setConsistentSchema(filteredSchema));
+      dispatch(setConsistentFunctions(filteredFunctions));
+      dispatch(setConsistentRemoteSchemas(filteredRemoteSchemas));
+    }
+  };
 };
 
 export const loadInconsistentObjects = (
@@ -67,42 +110,65 @@ export const loadInconsistentObjects = (
 ) => {
   return (dispatch, getState) => {
     const headers = getState().tables.dataHeaders;
+
+    const loadQuery = shouldReloadCache
+      ? reloadCacheAndGetInconsistentObjectsQuery
+      : getInconsistentObjectsQuery;
+
     dispatch({ type: LOADING_METADATA });
     return dispatch(
       requestAction(endpoints.query, {
         method: 'POST',
         headers,
-        body: JSON.stringify(
-          shouldReloadCache
-            ? reloadCacheAndGetInconsistentObjectsQuery
-            : getInconsistentObjectsQuery
-        ),
+        body: JSON.stringify(loadQuery),
       })
     ).then(
       data => {
-        const allSchemas = getState().tables.allSchemas;
-        const functions = getState().tables.trackedFunctions;
         const inconsistentObjects = shouldReloadCache
           ? data[1].inconsistent_objects
           : data.inconsistent_objects;
-        dispatch({
-          type: LOAD_INCONSISTENT_OBJECTS,
-          data: inconsistentObjects,
-        });
-        if (inconsistentObjects.length > 0) {
-          const filteredSchema = filterInconsistentMetadata(
-            allSchemas,
-            inconsistentObjects,
-            'tables'
-          );
-          const filteredFunctions = filterInconsistentMetadata(
-            functions,
-            inconsistentObjects,
-            'functions'
-          );
-          dispatch(setConsistentSchema(filteredSchema));
-          dispatch(setConsistentFunctions(filteredFunctions));
+
+        dispatch(handleInconsistentObjects(inconsistentObjects));
+
+        if (successCb) {
+          successCb();
         }
+      },
+      error => {
+        console.error(error);
+        dispatch({ type: LOAD_METADATA_ERROR });
+        if (failureCb) {
+          failureCb(error);
+        }
+      }
+    );
+  };
+};
+
+/* Reloads only remote schema metadata */
+
+export const reloadRemoteSchema = (remoteSchemaName, successCb, failureCb) => {
+  return (dispatch, getState) => {
+    const headers = getState().tables.dataHeaders;
+    const { featuresCompatibility } = getState().main;
+
+    const reloadQuery = featuresCompatibility[RELOAD_METADATA_API_CHANGE]
+      ? reloadRemoteSchemaCacheAndGetInconsistentObjectsQuery(remoteSchemaName)
+      : reloadCacheAndGetInconsistentObjectsQuery;
+
+    dispatch({ type: LOADING_METADATA });
+    return dispatch(
+      requestAction(endpoints.query, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify(reloadQuery),
+      })
+    ).then(
+      data => {
+        const inconsistentObjects = data[1].inconsistent_objects;
+
+        dispatch(handleInconsistentObjects(inconsistentObjects));
+
         if (successCb) {
           successCb();
         }