@pranaysahith/decap-cms-core 3.9.1

package/src/actions/notifications.ts

@@ -0,0 +1,36 @@
+import type { TypeOptions } from 'react-toastify';
+
+export interface NotificationMessage {
+  details?: unknown;
+  key: string;
+}
+
+export interface NotificationPayload {
+  message: string | NotificationMessage;
+  dismissAfter?: number;
+  type: TypeOptions | undefined;
+}
+
+export const NOTIFICATION_SEND = 'NOTIFICATION_SEND';
+export const NOTIFICATION_DISMISS = 'NOTIFICATION_DISMISS';
+export const NOTIFICATIONS_CLEAR = 'NOTIFICATION_CLEAR';
+
+function addNotification(notification: NotificationPayload) {
+  return { type: NOTIFICATION_SEND, payload: notification };
+}
+
+function dismissNotification(id: string) {
+  return { type: NOTIFICATION_DISMISS, id };
+}
+
+function clearNotifications() {
+  return { type: NOTIFICATIONS_CLEAR };
+}
+
+export type NotificationsAction = {
+  type: typeof NOTIFICATION_DISMISS | typeof NOTIFICATION_SEND | typeof NOTIFICATIONS_CLEAR;
+  payload?: NotificationPayload;
+  id?: string;
+};
+
+export { addNotification, dismissNotification, clearNotifications };

package/src/actions/search.ts

@@ -0,0 +1,221 @@
+import isEqual from 'lodash/isEqual';
+
+import { currentBackend } from '../backend';
+import { getIntegrationProvider } from '../integrations';
+import { selectIntegration } from '../reducers';
+
+import type { QueryRequest } from '../reducers/search';
+import type { State } from '../types/redux';
+import type { AnyAction } from 'redux';
+import type { ThunkDispatch } from 'redux-thunk';
+import type { EntryValue } from '../valueObjects/Entry';
+
+/*
+ * 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: string, searchCollections: string[], page: number) {
+  return {
+    type: SEARCH_ENTRIES_REQUEST,
+    payload: { searchTerm, searchCollections, page },
+  } as const;
+}
+
+export function searchSuccess(entries: EntryValue[], page: number) {
+  return {
+    type: SEARCH_ENTRIES_SUCCESS,
+    payload: {
+      entries,
+      page,
+    },
+  } as const;
+}
+
+export function searchFailure(error: Error) {
+  return {
+    type: SEARCH_ENTRIES_FAILURE,
+    payload: { error },
+  } as const;
+}
+
+export function querying(searchTerm: string, request?: QueryRequest) {
+  return {
+    type: QUERY_REQUEST,
+    payload: {
+      searchTerm,
+      request,
+    },
+  } as const;
+}
+
+type SearchResponse = {
+  entries: EntryValue[];
+  pagination: number;
+};
+
+type QueryResponse = {
+  hits: EntryValue[];
+  query: string;
+};
+
+export function querySuccess(namespace: string, hits: EntryValue[]) {
+  return {
+    type: QUERY_SUCCESS,
+    payload: {
+      namespace,
+      hits,
+    },
+  } as const;
+}
+
+export function queryFailure(error: Error) {
+  return {
+    type: QUERY_FAILURE,
+    payload: { error },
+  } as const;
+}
+
+/*
+ * Exported simple Action Creators
+ */
+
+export function clearSearch() {
+  return { type: SEARCH_CLEAR } as const;
+}
+
+export function clearRequests() {
+  return { type: CLEAR_REQUESTS } as const;
+}
+
+/*
+ * Exported Thunk Action Creators
+ */
+
+// SearchEntries will search for complete entries in all collections.
+export function searchEntries(searchTerm: string, searchCollections: string[], page = 0) {
+  return async (dispatch: ThunkDispatch<State, undefined, AnyAction>, getState: () => State) => {
+    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: string) => allCollections.indexOf(key) !== -1)
+            .valueSeq()
+            .toArray(),
+          searchTerm,
+        );
+
+    try {
+      const response: SearchResponse = 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: string,
+  collectionName: string,
+  searchFields: string[],
+  searchTerm: string,
+  file?: string,
+  limit?: number,
+) {
+  return async (dispatch: ThunkDispatch<State, {}, AnyAction>, getState: () => State) => {
+    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: QueryResponse = await queryPromise;
+      return dispatch(querySuccess(namespace, response.hits));
+    } catch (error) {
+      return dispatch(queryFailure(error));
+    }
+  };
+}
+
+export type SearchAction = ReturnType<
+  | typeof searchingEntries
+  | typeof searchSuccess
+  | typeof searchFailure
+  | typeof querying
+  | typeof querySuccess
+  | typeof queryFailure
+  | typeof clearSearch
+  | typeof clearRequests
+>;

package/src/actions/status.ts

@@ -0,0 +1,99 @@
+import { currentBackend } from '../backend';
+import { addNotification, dismissNotification } from './notifications';
+
+import type { ThunkDispatch } from 'redux-thunk';
+import type { AnyAction } from 'redux';
+import type { State } from '../types/redux';
+
+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,
+  } as const;
+}
+
+export function statusSuccess(status: {
+  auth: { status: boolean };
+  api: { status: boolean; statusPage: string };
+}) {
+  return {
+    type: STATUS_SUCCESS,
+    payload: { status },
+  } as const;
+}
+
+export function statusFailure(error: Error) {
+  return {
+    type: STATUS_FAILURE,
+    payload: { error },
+  } as const;
+}
+
+export function checkBackendStatus() {
+  return async (dispatch: ThunkDispatch<State, {}, AnyAction>, getState: () => State) => {
+    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));
+    }
+  };
+}
+
+export type StatusAction = ReturnType<
+  typeof statusRequest | typeof statusSuccess | typeof statusFailure
+>;

package/src/actions/waitUntil.ts

@@ -0,0 +1,49 @@
+import { WAIT_UNTIL_ACTION } from '../redux/middleware/waitUntilAction';
+
+import type { WaitActionArgs } from '../redux/middleware/waitUntilAction';
+import type { ThunkDispatch } from 'redux-thunk';
+import type { AnyAction } from 'redux';
+import type { State } from '../types/redux';
+
+export function waitUntil({ predicate, run }: WaitActionArgs) {
+  return {
+    type: WAIT_UNTIL_ACTION,
+    predicate,
+    run,
+  };
+}
+
+export async function waitUntilWithTimeout<T>(
+  dispatch: ThunkDispatch<State, {}, AnyAction>,
+  waitActionArgs: (resolve: (value?: T) => void) => WaitActionArgs,
+  timeout = 30000,
+): Promise<T | null | void> {
+  let waitDone = false;
+
+  const waitPromise = new Promise<T>(resolve => {
+    dispatch(waitUntil(waitActionArgs(resolve as (value?: T | undefined) => void)));
+  });
+
+  const timeoutPromise = new Promise<T | null | void>(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;
+}