@pranaysahith/decap-cms-core 3.9.1

package/dist/esm/actions/search.js

@@ -0,0 +1,149 @@
+import isEqual from 'lodash/isEqual';
+import { currentBackend } from '../backend';
+import { getIntegrationProvider } from '../integrations';
+import { selectIntegration } from '../reducers';
+/*
+ * Constant Declarations
+ */
+export const SEARCH_ENTRIES_REQUEST = 'SEARCH_ENTRIES_REQUEST';
+export const SEARCH_ENTRIES_SUCCESS = 'SEARCH_ENTRIES_SUCCESS';
+export const SEARCH_ENTRIES_FAILURE = 'SEARCH_ENTRIES_FAILURE';
+export const QUERY_REQUEST = 'QUERY_REQUEST';
+export const QUERY_SUCCESS = 'QUERY_SUCCESS';
+export const QUERY_FAILURE = 'QUERY_FAILURE';
+export const SEARCH_CLEAR = 'SEARCH_CLEAR';
+export const CLEAR_REQUESTS = 'CLEAR_REQUESTS';
+
+/*
+ * Simple Action Creators (Internal)
+ * We still need to export them for tests
+ */
+export function searchingEntries(searchTerm, searchCollections, page) {
+  return {
+    type: SEARCH_ENTRIES_REQUEST,
+    payload: {
+      searchTerm,
+      searchCollections,
+      page
+    }
+  };
+}
+export function searchSuccess(entries, page) {
+  return {
+    type: SEARCH_ENTRIES_SUCCESS,
+    payload: {
+      entries,
+      page
+    }
+  };
+}
+export function searchFailure(error) {
+  return {
+    type: SEARCH_ENTRIES_FAILURE,
+    payload: {
+      error
+    }
+  };
+}
+export function querying(searchTerm, request) {
+  return {
+    type: QUERY_REQUEST,
+    payload: {
+      searchTerm,
+      request
+    }
+  };
+}
+export function querySuccess(namespace, hits) {
+  return {
+    type: QUERY_SUCCESS,
+    payload: {
+      namespace,
+      hits
+    }
+  };
+}
+export function queryFailure(error) {
+  return {
+    type: QUERY_FAILURE,
+    payload: {
+      error
+    }
+  };
+}
+
+/*
+ * Exported simple Action Creators
+ */
+
+export function clearSearch() {
+  return {
+    type: SEARCH_CLEAR
+  };
+}
+export function clearRequests() {
+  return {
+    type: CLEAR_REQUESTS
+  };
+}
+
+/*
+ * Exported Thunk Action Creators
+ */
+
+// SearchEntries will search for complete entries in all collections.
+export function searchEntries(searchTerm, searchCollections, page = 0) {
+  return async (dispatch, getState) => {
+    const state = getState();
+    const {
+      search
+    } = state;
+    const backend = currentBackend(state.config);
+    const allCollections = searchCollections || state.collections.keySeq().toArray();
+    const collections = allCollections.filter(collection => selectIntegration(state, collection, 'search'));
+    const integration = selectIntegration(state, collections[0], 'search');
+
+    // avoid duplicate searches
+    if (search.isFetching && search.term === searchTerm && isEqual(allCollections, search.collections) && (
+    // if an integration doesn't exist, 'page' is not used
+    search.page === page || !integration)) {
+      return;
+    }
+    dispatch(searchingEntries(searchTerm, allCollections, page));
+    const searchPromise = integration ? getIntegrationProvider(state.integrations, backend.getToken, integration).search(collections, searchTerm, page) : backend.search(state.collections.filter((_, key) => allCollections.indexOf(key) !== -1).valueSeq().toArray(), searchTerm);
+    try {
+      const response = await searchPromise;
+      return dispatch(searchSuccess(response.entries, response.pagination));
+    } catch (error) {
+      return dispatch(searchFailure(error));
+    }
+  };
+}
+
+// Instead of searching for complete entries, query will search for specific fields
+// in specific collections and return raw data (no entries).
+export function query(namespace, collectionName, searchFields, searchTerm, file, limit) {
+  return async (dispatch, getState) => {
+    const state = getState();
+    const backend = currentBackend(state.config);
+    const integration = selectIntegration(state, collectionName, 'search');
+    const collection = state.collections.find(collection => collection.get('name') === collectionName);
+    dispatch(clearRequests());
+    const queryIdentifier = `${collectionName}-${searchFields.join()}-${searchTerm}-${file}-${limit}`;
+    const queuedQueryPromise = state.search.requests.find(({
+      id
+    }) => id == queryIdentifier);
+    const queryPromise = queuedQueryPromise ? queuedQueryPromise.queryResponse : integration ? getIntegrationProvider(state.integrations, backend.getToken, integration).searchBy(searchFields.map(f => `data.${f}`), collectionName, searchTerm) : backend.query(collection, searchFields, searchTerm, file, limit);
+    dispatch(querying(searchTerm, queuedQueryPromise ? undefined : {
+      id: queryIdentifier,
+      expires: new Date(new Date().getTime() + 10 * 1000),
+      queryResponse: queryPromise
+    }));
+    try {
+      const response = await queryPromise;
+      return dispatch(querySuccess(namespace, response.hits));
+    } catch (error) {
+      return dispatch(queryFailure(error));
+    }
+  };
+}

package/dist/esm/actions/status.js

@@ -0,0 +1,74 @@
+import { currentBackend } from '../backend';
+import { addNotification, dismissNotification } from './notifications';
+export const STATUS_REQUEST = 'STATUS_REQUEST';
+export const STATUS_SUCCESS = 'STATUS_SUCCESS';
+export const STATUS_FAILURE = 'STATUS_FAILURE';
+export function statusRequest() {
+  return {
+    type: STATUS_REQUEST
+  };
+}
+export function statusSuccess(status) {
+  return {
+    type: STATUS_SUCCESS,
+    payload: {
+      status
+    }
+  };
+}
+export function statusFailure(error) {
+  return {
+    type: STATUS_FAILURE,
+    payload: {
+      error
+    }
+  };
+}
+export function checkBackendStatus() {
+  return async (dispatch, getState) => {
+    try {
+      const state = getState();
+      if (state.status.isFetching) {
+        return;
+      }
+      dispatch(statusRequest());
+      const backend = currentBackend(state.config);
+      const status = await backend.status();
+      const backendDownKey = 'ui.toast.onBackendDown';
+      const previousBackendDownNotifications = state.notifications.notifications.filter(n => typeof n.message != 'string' && n.message?.key === backendDownKey);
+      if (status.api.status === false) {
+        if (previousBackendDownNotifications.length === 0) {
+          dispatch(addNotification({
+            message: {
+              details: status.api.statusPage,
+              key: 'ui.toast.onBackendDown'
+            },
+            type: 'error'
+          }));
+        }
+        return dispatch(statusSuccess(status));
+      } else if (status.api.status === true && previousBackendDownNotifications.length > 0) {
+        // If backend is up, clear all the danger messages
+        previousBackendDownNotifications.forEach(notification => {
+          dispatch(dismissNotification(notification.id));
+        });
+      }
+      const authError = status.auth.status === false;
+      if (authError) {
+        const key = 'ui.toast.onLoggedOut';
+        const existingNotification = state.notifications.notifications.find(n => typeof n.message != 'string' && n.message?.key === key);
+        if (!existingNotification) {
+          dispatch(addNotification({
+            message: {
+              key: 'ui.toast.onLoggedOut'
+            },
+            type: 'error'
+          }));
+        }
+      }
+      dispatch(statusSuccess(status));
+    } catch (error) {
+      dispatch(statusFailure(error));
+    }
+  };
+}

package/dist/esm/actions/waitUntil.js

@@ -0,0 +1,32 @@
+import { WAIT_UNTIL_ACTION } from '../redux/middleware/waitUntilAction';
+export function waitUntil({
+  predicate,
+  run
+}) {
+  return {
+    type: WAIT_UNTIL_ACTION,
+    predicate,
+    run
+  };
+}
+export async function waitUntilWithTimeout(dispatch, waitActionArgs, timeout = 30000) {
+  let waitDone = false;
+  const waitPromise = new Promise(resolve => {
+    dispatch(waitUntil(waitActionArgs(resolve)));
+  });
+  const timeoutPromise = new Promise(resolve => {
+    setTimeout(() => {
+      if (waitDone) {
+        resolve();
+      } else {
+        console.warn('Wait Action timed out');
+        resolve(null);
+      }
+    }, timeout);
+  });
+  const result = await Promise.race([waitPromise.then(result => {
+    waitDone = true;
+    return result;
+  }).catch(null), timeoutPromise]);
+  return result;
+}