@pranaysahith/decap-cms-core 3.9.1

package/src/reducers/entryDraft.js

@@ -0,0 +1,260 @@
+import { Map, List, fromJS } from 'immutable';
+import { v4 as uuid } from 'uuid';
+import get from 'lodash/get';
+import { join } from 'path';
+
+import {
+  DRAFT_CREATE_FROM_ENTRY,
+  DRAFT_CREATE_EMPTY,
+  DRAFT_DISCARD,
+  DRAFT_CHANGE_FIELD,
+  DRAFT_VALIDATION_ERRORS,
+  DRAFT_CLEAR_ERRORS,
+  DRAFT_LOCAL_BACKUP_RETRIEVED,
+  DRAFT_CREATE_FROM_LOCAL_BACKUP,
+  DRAFT_CREATE_DUPLICATE_FROM_ENTRY,
+  ENTRY_PERSIST_REQUEST,
+  ENTRY_PERSIST_SUCCESS,
+  ENTRY_PERSIST_FAILURE,
+  ENTRY_DELETE_SUCCESS,
+  ADD_DRAFT_ENTRY_MEDIA_FILE,
+  REMOVE_DRAFT_ENTRY_MEDIA_FILE,
+} from '../actions/entries';
+import {
+  UNPUBLISHED_ENTRY_PERSIST_REQUEST,
+  UNPUBLISHED_ENTRY_PERSIST_SUCCESS,
+  UNPUBLISHED_ENTRY_PERSIST_FAILURE,
+  UNPUBLISHED_ENTRY_STATUS_CHANGE_REQUEST,
+  UNPUBLISHED_ENTRY_STATUS_CHANGE_SUCCESS,
+  UNPUBLISHED_ENTRY_STATUS_CHANGE_FAILURE,
+  UNPUBLISHED_ENTRY_PUBLISH_REQUEST,
+  UNPUBLISHED_ENTRY_PUBLISH_SUCCESS,
+  UNPUBLISHED_ENTRY_PUBLISH_FAILURE,
+} from '../actions/editorialWorkflow';
+import { selectFolderEntryExtension, selectHasMetaPath } from './collections';
+import { getDataPath, duplicateI18nFields } from '../lib/i18n';
+
+const initialState = Map({
+  entry: Map(),
+  fieldsMetaData: Map(),
+  fieldsErrors: Map(),
+  hasChanged: false,
+  key: '',
+});
+
+function entryDraftReducer(state = Map(), action) {
+  switch (action.type) {
+    case DRAFT_CREATE_FROM_ENTRY:
+      // Existing Entry
+      return state.withMutations(state => {
+        state.set('entry', fromJS(action.payload.entry));
+        state.setIn(['entry', 'newRecord'], false);
+        state.set('fieldsMetaData', Map());
+        state.set('fieldsErrors', Map());
+        state.set('hasChanged', false);
+        state.set('key', uuid());
+      });
+    case DRAFT_CREATE_EMPTY:
+      // New Entry
+      return state.withMutations(state => {
+        state.set('entry', fromJS(action.payload));
+        state.setIn(['entry', 'newRecord'], true);
+        state.set('fieldsMetaData', Map());
+        state.set('fieldsErrors', Map());
+        state.set('hasChanged', false);
+        state.set('key', uuid());
+      });
+    case DRAFT_CREATE_FROM_LOCAL_BACKUP:
+      // Local Backup
+      return state.withMutations(state => {
+        const backupDraftEntry = state.get('localBackup');
+        const backupEntry = backupDraftEntry.get('entry');
+        state.delete('localBackup');
+        state.set('entry', backupEntry);
+        state.setIn(['entry', 'newRecord'], !backupEntry.get('path'));
+        state.set('fieldsMetaData', Map());
+        state.set('fieldsErrors', Map());
+        state.set('hasChanged', true);
+        state.set('key', uuid());
+      });
+    case DRAFT_CREATE_DUPLICATE_FROM_ENTRY:
+      // Duplicate Entry
+      return state.withMutations(state => {
+        state.set('entry', fromJS(action.payload));
+        state.setIn(['entry', 'newRecord'], true);
+        state.set('mediaFiles', List());
+        state.set('fieldsMetaData', Map());
+        state.set('fieldsErrors', Map());
+        state.set('hasChanged', true);
+      });
+    case DRAFT_DISCARD:
+      return initialState;
+    case DRAFT_LOCAL_BACKUP_RETRIEVED: {
+      const { entry } = action.payload;
+      const newState = new Map({
+        entry: fromJS(entry),
+      });
+      return state.set('localBackup', newState);
+    }
+    case DRAFT_CHANGE_FIELD: {
+      return state.withMutations(state => {
+        const { field, value, metadata, entries, i18n } = action.payload;
+        const name = field.get('name');
+        const meta = field.get('meta');
+
+        const dataPath = (i18n && getDataPath(i18n.currentLocale, i18n.defaultLocale)) || ['data'];
+        if (meta) {
+          state.setIn(['entry', 'meta', name], value);
+        } else {
+          state.setIn(['entry', ...dataPath, name], value);
+          if (i18n) {
+            state = duplicateI18nFields(state, field, i18n.locales, i18n.defaultLocale);
+          }
+        }
+        state.mergeDeepIn(['fieldsMetaData'], fromJS(metadata));
+        const newData = state.getIn(['entry', ...dataPath]);
+        const newMeta = state.getIn(['entry', 'meta']);
+        state.set(
+          'hasChanged',
+          !entries.some(e => newData.equals(e.get(...dataPath))) ||
+            !entries.some(e => newMeta.equals(e.get('meta'))),
+        );
+      });
+    }
+    case DRAFT_VALIDATION_ERRORS:
+      if (action.payload.errors.length === 0) {
+        return state.deleteIn(['fieldsErrors', action.payload.uniquefieldId]);
+      } else {
+        return state.setIn(['fieldsErrors', action.payload.uniquefieldId], action.payload.errors);
+      }
+
+    case DRAFT_CLEAR_ERRORS: {
+      const { uniqueFieldId } = action.payload;
+      return state.deleteIn(['fieldsErrors', uniqueFieldId]);
+    }
+
+    case ENTRY_PERSIST_REQUEST:
+    case UNPUBLISHED_ENTRY_PERSIST_REQUEST: {
+      return state.setIn(['entry', 'isPersisting'], true);
+    }
+
+    case ENTRY_PERSIST_FAILURE:
+    case UNPUBLISHED_ENTRY_PERSIST_FAILURE: {
+      return state.deleteIn(['entry', 'isPersisting']);
+    }
+
+    case UNPUBLISHED_ENTRY_STATUS_CHANGE_REQUEST:
+      return state.setIn(['entry', 'isUpdatingStatus'], true);
+
+    case UNPUBLISHED_ENTRY_STATUS_CHANGE_FAILURE:
+    case UNPUBLISHED_ENTRY_STATUS_CHANGE_SUCCESS:
+      return state.deleteIn(['entry', 'isUpdatingStatus']);
+
+    case UNPUBLISHED_ENTRY_PUBLISH_REQUEST:
+      return state.setIn(['entry', 'isPublishing'], true);
+
+    case UNPUBLISHED_ENTRY_PUBLISH_SUCCESS:
+    case UNPUBLISHED_ENTRY_PUBLISH_FAILURE:
+      return state.deleteIn(['entry', 'isPublishing']);
+
+    case ENTRY_PERSIST_SUCCESS:
+    case UNPUBLISHED_ENTRY_PERSIST_SUCCESS:
+      return state.withMutations(state => {
+        state.deleteIn(['entry', 'isPersisting']);
+        state.set('hasChanged', false);
+        if (!state.getIn(['entry', 'slug'])) {
+          state.setIn(['entry', 'slug'], action.payload.slug);
+        }
+      });
+
+    case ENTRY_DELETE_SUCCESS:
+      return state.withMutations(state => {
+        state.deleteIn(['entry', 'isPersisting']);
+        state.set('hasChanged', false);
+      });
+
+    case ADD_DRAFT_ENTRY_MEDIA_FILE: {
+      return state.withMutations(state => {
+        const mediaFiles = state.getIn(['entry', 'mediaFiles']);
+
+        state.setIn(
+          ['entry', 'mediaFiles'],
+          mediaFiles
+            .filterNot(file => file.get('id') === action.payload.id)
+            .insert(0, fromJS(action.payload)),
+        );
+        state.set('hasChanged', true);
+      });
+    }
+
+    case REMOVE_DRAFT_ENTRY_MEDIA_FILE: {
+      return state.withMutations(state => {
+        const mediaFiles = state.getIn(['entry', 'mediaFiles']);
+
+        state.setIn(
+          ['entry', 'mediaFiles'],
+          mediaFiles.filterNot(file => file.get('id') === action.payload.id),
+        );
+        state.set('hasChanged', true);
+      });
+    }
+
+    default:
+      return state;
+  }
+}
+
+function cleanTitleForFilename(title) {
+  if (!title) return 'untitled';
+  // Convert to lowercase, replace spaces and special chars with hyphens
+  return title
+    .toString()
+    .toLowerCase()
+    .trim()
+    .replace(/[^\w\s-]/g, '') // Remove special characters
+    .replace(/[\s_]+/g, '-') // Replace spaces and underscores with hyphens
+    .replace(/^-+|-+$/g, ''); // Remove leading/trailing hyphens
+}
+
+export function selectCustomPath(collection, entryDraft) {
+  if (!selectHasMetaPath(collection)) {
+    return;
+  }
+  const meta = entryDraft.getIn(['entry', 'meta']);
+  const path = meta && meta.get('path');
+
+  if (!path) {
+    return;
+  }
+
+  const extension = selectFolderEntryExtension(collection);
+  const indexFile = get(collection.toJS(), ['meta', 'path', 'index_file']);
+
+  // If index_file is specified, use the old behavior for backward compatibility
+  if (indexFile) {
+    const customPath = join(collection.get('folder'), path, `${indexFile}.${extension}`);
+    return customPath;
+  }
+
+  // New behavior: generate filename from entry title
+  const isNewEntry = entryDraft.getIn(['entry', 'newRecord']);
+  const currentPath = entryDraft.getIn(['entry', 'path']);
+
+  let filename;
+  if (isNewEntry || !currentPath) {
+    // For new entries, generate filename from title
+    const entryData = entryDraft.getIn(['entry', 'data']);
+    const title = entryData && entryData.get('title');
+    filename = cleanTitleForFilename(title);
+  } else {
+    // For existing entries, preserve the current filename
+    const { basename: basenameFunc } = require('path');
+    const currentFilename = basenameFunc(currentPath, `.${extension}`);
+    filename = currentFilename;
+  }
+
+  const customPath = join(collection.get('folder'), path, `${filename}.${extension}`);
+  return customPath;
+}
+
+export default entryDraftReducer;

package/src/reducers/globalUI.ts

@@ -0,0 +1,45 @@
+import { produce } from 'immer';
+
+import { USE_OPEN_AUTHORING } from '../actions/auth';
+
+import type { AnyAction } from 'redux';
+
+export type GlobalUI = {
+  isFetching: boolean;
+  useOpenAuthoring: boolean;
+};
+
+const LOADING_IGNORE_LIST = [
+  'DEPLOY_PREVIEW',
+  'STATUS_REQUEST',
+  'STATUS_SUCCESS',
+  'STATUS_FAILURE',
+];
+
+function ignoreWhenLoading(action: AnyAction) {
+  return LOADING_IGNORE_LIST.some(type => action.type.includes(type));
+}
+
+const defaultState: GlobalUI = {
+  isFetching: false,
+  useOpenAuthoring: false,
+};
+
+/**
+ * Reducer for some global UI state that we want to share between components
+ */
+const globalUI = produce((state: GlobalUI, action: AnyAction) => {
+  // Generic, global loading indicator
+  if (!ignoreWhenLoading(action) && action.type.includes('REQUEST')) {
+    state.isFetching = true;
+  } else if (
+    !ignoreWhenLoading(action) &&
+    (action.type.includes('SUCCESS') || action.type.includes('FAILURE'))
+  ) {
+    state.isFetching = false;
+  } else if (action.type === USE_OPEN_AUTHORING) {
+    state.useOpenAuthoring = true;
+  }
+}, defaultState);
+
+export default globalUI;

package/src/reducers/index.ts

@@ -0,0 +1,82 @@
+import { List } from 'immutable';
+
+import auth from './auth';
+import config from './config';
+import integrations, * as fromIntegrations from './integrations';
+import entries, * as fromEntries from './entries';
+import cursors from './cursors';
+import editorialWorkflow, * as fromEditorialWorkflow from './editorialWorkflow';
+import entryDraft from './entryDraft';
+import collections from './collections';
+import search from './search';
+import medias from './medias';
+import mediaLibrary from './mediaLibrary';
+import deploys, * as fromDeploys from './deploys';
+import globalUI from './globalUI';
+import status from './status';
+import notifications from './notifications';
+
+import type { Status } from '../constants/publishModes';
+import type { State, Collection } from '../types/redux';
+
+const reducers = {
+  auth,
+  config,
+  collections,
+  search,
+  integrations,
+  entries,
+  cursors,
+  editorialWorkflow,
+  entryDraft,
+  medias,
+  mediaLibrary,
+  deploys,
+  globalUI,
+  status,
+  notifications,
+};
+
+export default reducers;
+
+/*
+ * Selectors
+ */
+export function selectEntry(state: State, collection: string, slug: string) {
+  return fromEntries.selectEntry(state.entries, collection, slug);
+}
+
+export function selectEntries(state: State, collection: Collection) {
+  return fromEntries.selectEntries(state.entries, collection);
+}
+
+export function selectPublishedSlugs(state: State, collection: string) {
+  return fromEntries.selectPublishedSlugs(state.entries, collection);
+}
+
+export function selectSearchedEntries(state: State, availableCollections: string[]) {
+  // only return search results for actually available collections
+  return List(state.search.entryIds)
+    .filter(entryId => availableCollections.indexOf(entryId!.collection) !== -1)
+    .map(entryId => fromEntries.selectEntry(state.entries, entryId!.collection, entryId!.slug));
+}
+
+export function selectDeployPreview(state: State, collection: string, slug: string) {
+  return fromDeploys.selectDeployPreview(state.deploys, collection, slug);
+}
+
+export function selectUnpublishedEntry(state: State, collection: string, slug: string) {
+  return fromEditorialWorkflow.selectUnpublishedEntry(state.editorialWorkflow, collection, slug);
+}
+
+export function selectUnpublishedEntriesByStatus(state: State, status: Status) {
+  return fromEditorialWorkflow.selectUnpublishedEntriesByStatus(state.editorialWorkflow, status);
+}
+
+export function selectUnpublishedSlugs(state: State, collection: string) {
+  return fromEditorialWorkflow.selectUnpublishedSlugs(state.editorialWorkflow, collection);
+}
+
+export function selectIntegration(state: State, collection: string | null, hook: string) {
+  return fromIntegrations.selectIntegration(state.integrations, collection, hook);
+}

package/src/reducers/integrations.ts

@@ -0,0 +1,59 @@
+import { fromJS } from 'immutable';
+
+import { CONFIG_SUCCESS } from '../actions/config';
+
+import type { ConfigAction } from '../actions/config';
+import type { Integrations, CmsConfig } from '../types/redux';
+
+interface Acc {
+  providers: Record<string, {}>;
+  hooks: Record<string, string | Record<string, string>>;
+}
+
+export function getIntegrations(config: CmsConfig) {
+  const integrations = config.integrations || [];
+  const newState = integrations.reduce(
+    (acc, integration) => {
+      const { hooks, collections, provider, ...providerData } = integration;
+      acc.providers[provider] = { ...providerData };
+      if (!collections) {
+        hooks.forEach(hook => {
+          acc.hooks[hook] = provider;
+        });
+        return acc;
+      }
+      const integrationCollections =
+        collections === '*' ? config.collections.map(collection => collection.name) : collections;
+      integrationCollections.forEach(collection => {
+        hooks.forEach(hook => {
+          acc.hooks[collection]
+            ? ((acc.hooks[collection] as Record<string, string>)[hook] = provider)
+            : (acc.hooks[collection] = { [hook]: provider });
+        });
+      });
+      return acc;
+    },
+    { providers: {}, hooks: {} } as Acc,
+  );
+  return fromJS(newState);
+}
+
+const defaultState = fromJS({ providers: {}, hooks: {} });
+
+function integrations(state = defaultState, action: ConfigAction): Integrations | null {
+  switch (action.type) {
+    case CONFIG_SUCCESS: {
+      return getIntegrations(action.payload);
+    }
+    default:
+      return state;
+  }
+}
+
+export function selectIntegration(state: Integrations, collection: string | null, hook: string) {
+  return collection
+    ? state.getIn(['hooks', collection, hook], false)
+    : state.getIn(['hooks', hook], false);
+}
+
+export default integrations;