@pranaysahith/decap-cms-core 3.9.1

package/src/reducers/__tests__/entryDraft.spec.js

@@ -0,0 +1,297 @@
+import { Map, fromJS } from 'immutable';
+
+import * as actions from '../../actions/entries';
+import reducer from '../entryDraft';
+
+jest.mock('uuid', () => ({ v4: jest.fn(() => '1') }));
+
+const initialState = Map({
+  entry: Map(),
+  fieldsMetaData: Map(),
+  fieldsErrors: Map(),
+  hasChanged: false,
+  key: '',
+});
+
+const entry = {
+  collection: 'posts',
+  slug: 'slug',
+  path: 'content/blog/art-and-wine-festival.md',
+  partial: false,
+  raw: '',
+  data: {},
+  metaData: null,
+};
+
+describe('entryDraft reducer', () => {
+  describe('DRAFT_CREATE_FROM_ENTRY', () => {
+    it('should create draft from the entry', () => {
+      const state = reducer(initialState, actions.createDraftFromEntry(fromJS(entry)));
+      expect(state).toEqual(
+        fromJS({
+          entry: {
+            ...entry,
+            newRecord: false,
+          },
+          fieldsMetaData: Map(),
+          fieldsErrors: Map(),
+          hasChanged: false,
+          key: '1',
+        }),
+      );
+    });
+  });
+
+  describe('DRAFT_CREATE_EMPTY', () => {
+    it('should create a new draft ', () => {
+      const state = reducer(initialState, actions.emptyDraftCreated(fromJS(entry)));
+      expect(state).toEqual(
+        fromJS({
+          entry: {
+            ...entry,
+            newRecord: true,
+          },
+          fieldsMetaData: Map(),
+          fieldsErrors: Map(),
+          hasChanged: false,
+          key: '1',
+        }),
+      );
+    });
+  });
+
+  describe('DRAFT_DISCARD', () => {
+    it('should discard the draft and return initial state', () => {
+      expect(reducer(initialState, actions.discardDraft())).toEqual(initialState);
+    });
+  });
+
+  describe('persisting', () => {
+    let initialState;
+
+    beforeEach(() => {
+      initialState = fromJS({
+        entities: {
+          'posts.slug': {
+            collection: 'posts',
+            slug: 'slug',
+            path: 'content/blog/art-and-wine-festival.md',
+            partial: false,
+            raw: '',
+            data: {},
+            metaData: null,
+          },
+        },
+        pages: {},
+      });
+    });
+
+    it('should handle persisting request', () => {
+      const newState = reducer(
+        initialState,
+        actions.entryPersisting(Map({ name: 'posts' }), Map({ slug: 'slug' })),
+      );
+      expect(newState.getIn(['entry', 'isPersisting'])).toBe(true);
+    });
+
+    it('should handle persisting success', () => {
+      let newState = reducer(
+        initialState,
+        actions.entryPersisting(Map({ name: 'posts' }), Map({ slug: 'slug' })),
+      );
+      newState = reducer(
+        newState,
+        actions.entryPersisted(Map({ name: 'posts' }), Map({ slug: 'slug' })),
+      );
+      expect(newState.getIn(['entry', 'isPersisting'])).toBeUndefined();
+    });
+
+    it('should handle persisting error', () => {
+      let newState = reducer(
+        initialState,
+        actions.entryPersisting(Map({ name: 'posts' }), Map({ slug: 'slug' })),
+      );
+      newState = reducer(
+        newState,
+        actions.entryPersistFail(Map({ name: 'posts' }), Map({ slug: 'slug' }), 'Error message'),
+      );
+      expect(newState.getIn(['entry', 'isPersisting'])).toBeUndefined();
+    });
+  });
+
+  describe('REMOVE_DRAFT_ENTRY_MEDIA_FILE', () => {
+    it('should remove a media file', () => {
+      const actualState = reducer(
+        initialState.setIn(['entry', 'mediaFiles'], fromJS([{ id: '1' }, { id: '2' }])),
+        actions.removeDraftEntryMediaFile({ id: '1' }),
+      );
+
+      expect(actualState.toJS()).toEqual({
+        entry: { mediaFiles: [{ id: '2' }] },
+        fieldsMetaData: {},
+        fieldsErrors: {},
+        hasChanged: true,
+        key: '',
+      });
+    });
+  });
+
+  describe('ADD_DRAFT_ENTRY_MEDIA_FILE', () => {
+    it('should overwrite an existing media file', () => {
+      const actualState = reducer(
+        initialState.setIn(['entry', 'mediaFiles'], fromJS([{ id: '1', name: 'old' }])),
+        actions.addDraftEntryMediaFile({ id: '1', name: 'new' }),
+      );
+
+      expect(actualState.toJS()).toEqual({
+        entry: { mediaFiles: [{ id: '1', name: 'new' }] },
+        fieldsMetaData: {},
+        fieldsErrors: {},
+        hasChanged: true,
+        key: '',
+      });
+    });
+  });
+
+  describe('DRAFT_CREATE_FROM_LOCAL_BACKUP', () => {
+    it('should create draft from local backup', () => {
+      const localBackup = Map({ entry: fromJS({ ...entry, mediaFiles: [{ id: '1' }] }) });
+
+      const actualState = reducer(initialState.set('localBackup', localBackup), {
+        type: actions.DRAFT_CREATE_FROM_LOCAL_BACKUP,
+      });
+      expect(actualState.toJS()).toEqual({
+        entry: {
+          ...entry,
+          mediaFiles: [{ id: '1' }],
+          newRecord: false,
+        },
+        fieldsMetaData: {},
+        fieldsErrors: {},
+        hasChanged: true,
+        key: '1',
+      });
+    });
+  });
+
+  describe('DRAFT_LOCAL_BACKUP_RETRIEVED', () => {
+    it('should set local backup', () => {
+      const mediaFiles = [{ id: '1' }];
+
+      const actualState = reducer(
+        initialState,
+        actions.localBackupRetrieved({ ...entry, mediaFiles }),
+      );
+
+      expect(actualState.toJS()).toEqual({
+        entry: {},
+        fieldsMetaData: {},
+        fieldsErrors: {},
+        hasChanged: false,
+        localBackup: {
+          entry: { ...entry, mediaFiles: [{ id: '1' }] },
+        },
+        key: '',
+      });
+    });
+  });
+
+  describe('selectCustomPath', () => {
+    let selectCustomPath;
+    let selectHasMetaPath;
+    let selectFolderEntryExtension;
+
+    beforeEach(() => {
+      jest.resetModules();
+      selectHasMetaPath = jest.fn(
+        collection => collection.has('meta') && collection.get('meta').has('path'),
+      );
+      selectFolderEntryExtension = jest.fn(collection => collection.get('extension') || 'md');
+
+      jest.doMock('../collections', () => ({
+        selectHasMetaPath,
+        selectFolderEntryExtension,
+      }));
+
+      const entryDraftModule = require('../entryDraft');
+      selectCustomPath = entryDraftModule.selectCustomPath;
+    });
+
+    afterEach(() => {
+      jest.unmock('../collections');
+    });
+
+    it('should generate dynamic filename for new entries without index_file', () => {
+      const collection = fromJS({
+        folder: '_pages',
+        extension: 'md',
+        meta: { path: { label: 'Path', widget: 'string' } },
+      });
+      const entryDraft = fromJS({
+        entry: {
+          newRecord: true,
+          data: { title: 'My Great Article' },
+          meta: { path: 'blog' },
+        },
+      });
+
+      const result = selectCustomPath(collection, entryDraft);
+      expect(result).toBe('_pages/blog/my-great-article.md');
+    });
+
+    it('should preserve filename for existing entries without index_file', () => {
+      const collection = fromJS({
+        folder: '_pages',
+        extension: 'md',
+        meta: { path: { label: 'Path', widget: 'string' } },
+      });
+      const entryDraft = fromJS({
+        entry: {
+          newRecord: false,
+          path: '_pages/old-folder/existing-file.md',
+          data: { title: 'Updated Title' },
+          meta: { path: 'new-folder' },
+        },
+      });
+
+      const result = selectCustomPath(collection, entryDraft);
+      expect(result).toBe('_pages/new-folder/existing-file.md');
+    });
+
+    it('should use index_file when specified (backward compatibility)', () => {
+      const collection = fromJS({
+        folder: '_pages',
+        extension: 'md',
+        meta: { path: { label: 'Path', widget: 'string', index_file: 'index' } },
+      });
+      const entryDraft = fromJS({
+        entry: {
+          newRecord: true,
+          data: { title: 'My Article' },
+          meta: { path: 'blog' },
+        },
+      });
+
+      const result = selectCustomPath(collection, entryDraft);
+      expect(result).toBe('_pages/blog/index.md');
+    });
+
+    it('should return undefined when path is not set', () => {
+      const collection = fromJS({
+        folder: '_pages',
+        extension: 'md',
+        meta: { path: { label: 'Path', widget: 'string' } },
+      });
+      const entryDraft = fromJS({
+        entry: {
+          newRecord: true,
+          data: { title: 'My Article' },
+          meta: {},
+        },
+      });
+
+      const result = selectCustomPath(collection, entryDraft);
+      expect(result).toBeUndefined();
+    });
+  });
+});

package/src/reducers/__tests__/globalUI.js

@@ -0,0 +1,43 @@
+import { USE_OPEN_AUTHORING } from '../../actions/auth';
+import {
+  DEPLOY_PREVIEW_REQUEST,
+  DEPLOY_PREVIEW_SUCCESS,
+  DEPLOY_PREVIEW_FAILURE,
+} from '../../actions/deploys';
+import { ENTRY_REQUEST, ENTRY_SUCCESS, ENTRY_FAILURE } from '../../actions/entries';
+import reducer from '../globalUI';
+
+describe('globalUI', () => {
+  it('should set isFetching to true on entry request', () => {
+    expect(reducer({ isFetching: false }, { type: ENTRY_REQUEST })).toEqual({ isFetching: true });
+  });
+
+  it('should set isFetching to false on entry success', () => {
+    expect(reducer({ isFetching: true }, { type: ENTRY_SUCCESS })).toEqual({ isFetching: false });
+  });
+
+  it('should set isFetching to false on entry failure', () => {
+    expect(reducer({ isFetching: true }, { type: ENTRY_FAILURE })).toEqual({ isFetching: false });
+  });
+
+  it('should not change state on deploy preview request', () => {
+    const state = { isFetching: false };
+    expect(reducer(state, { type: DEPLOY_PREVIEW_REQUEST })).toBe(state);
+  });
+
+  it('should not change state on deploy preview success', () => {
+    const state = { isFetching: true };
+    expect(reducer(state, { type: DEPLOY_PREVIEW_SUCCESS })).toBe(state);
+  });
+
+  it('should not change state on deploy preview failure', () => {
+    const state = { isFetching: true };
+    expect(reducer(state, { type: DEPLOY_PREVIEW_FAILURE })).toBe(state);
+  });
+
+  it('should set useOpenAuthoring to true on USE_OPEN_AUTHORING', () => {
+    expect(reducer({ useOpenAuthoring: false }, { type: USE_OPEN_AUTHORING })).toEqual({
+      useOpenAuthoring: true,
+    });
+  });
+});

package/src/reducers/__tests__/integrations.spec.ts

@@ -0,0 +1,76 @@
+import integrations from '../integrations';
+import { CONFIG_SUCCESS } from '../../actions/config';
+import { FOLDER } from '../../constants/collectionTypes';
+
+import type { ConfigAction } from '../../actions/config';
+
+describe('integrations', () => {
+  it('should return default state when no integrations', () => {
+    const result = integrations(null, {
+      type: CONFIG_SUCCESS,
+      payload: { integrations: [] },
+    } as ConfigAction);
+    expect(result && result.toJS()).toEqual({
+      providers: {},
+      hooks: {},
+    });
+  });
+
+  it('should return hooks and providers map when has integrations', () => {
+    const result = integrations(null, {
+      type: CONFIG_SUCCESS,
+      payload: {
+        integrations: [
+          {
+            hooks: ['listEntries'],
+            collections: '*',
+            provider: 'algolia',
+            applicationID: 'applicationID',
+            apiKey: 'apiKey',
+          },
+          {
+            hooks: ['listEntries'],
+            collections: ['posts'],
+            provider: 'algolia',
+            applicationID: 'applicationID',
+            apiKey: 'apiKey',
+          },
+          {
+            hooks: ['assetStore'],
+            provider: 'assetStore',
+            getSignedFormURL: 'https://asset.store.com/signedUrl',
+          },
+        ],
+        collections: [
+          { name: 'posts', label: 'Posts', type: FOLDER },
+          { name: 'pages', label: 'Pages', type: FOLDER },
+          { name: 'faq', label: 'FAQ', type: FOLDER },
+        ],
+      },
+    } as ConfigAction);
+
+    expect(result && result.toJS()).toEqual({
+      providers: {
+        algolia: {
+          applicationID: 'applicationID',
+          apiKey: 'apiKey',
+        },
+        assetStore: {
+          getSignedFormURL: 'https://asset.store.com/signedUrl',
+        },
+      },
+      hooks: {
+        posts: {
+          listEntries: 'algolia',
+        },
+        pages: {
+          listEntries: 'algolia',
+        },
+        faq: {
+          listEntries: 'algolia',
+        },
+        assetStore: 'assetStore',
+      },
+    });
+  });
+});

package/src/reducers/__tests__/mediaLibrary.spec.js

@@ -0,0 +1,154 @@
+import { Map, fromJS } from 'immutable';
+
+import { mediaDeleted } from '../../actions/mediaLibrary';
+import mediaLibrary, {
+  selectMediaFiles,
+  selectMediaFileByPath,
+  selectMediaDisplayURL,
+} from '../mediaLibrary';
+
+jest.mock('uuid');
+jest.mock('../entries');
+jest.mock('../');
+
+describe('mediaLibrary', () => {
+  it('should remove media file by key', () => {
+    expect(
+      mediaLibrary(
+        Map({
+          files: [{ key: 'key1' }, { key: 'key2' }],
+        }),
+        mediaDeleted({ key: 'key1' }),
+      ),
+    ).toEqual(
+      Map({
+        isDeleting: false,
+        files: [{ key: 'key2' }],
+      }),
+    );
+  });
+
+  it('should remove media file by id', () => {
+    expect(
+      mediaLibrary(
+        Map({
+          files: [{ id: 'id1' }, { id: 'id2' }],
+        }),
+        mediaDeleted({ id: 'id1' }),
+      ),
+    ).toEqual(
+      Map({
+        isDeleting: false,
+        files: [{ id: 'id2' }],
+      }),
+    );
+  });
+
+  it('should select draft media files from field when editing a draft', () => {
+    const { selectEditingDraft, selectMediaFolder } = require('../../reducers/entries');
+
+    selectEditingDraft.mockReturnValue(true);
+    selectMediaFolder.mockReturnValue('/static/images/posts/logos');
+
+    const imageField = fromJS({ name: 'image' });
+    const collection = fromJS({ fields: [imageField] });
+    const entry = fromJS({
+      collection: 'posts',
+      mediaFiles: [
+        { id: 1, path: '/static/images/posts/logos/logo.png' },
+        { id: 2, path: '/static/images/posts/general/image.png' },
+        { id: 3, path: '/static/images/posts/index.png' },
+      ],
+      data: {},
+    });
+    const state = {
+      config: {},
+      collections: fromJS({ posts: collection }),
+      entryDraft: fromJS({
+        entry,
+      }),
+    };
+
+    expect(selectMediaFiles(state, imageField)).toEqual([
+      { id: 1, key: 1, path: '/static/images/posts/logos/logo.png' },
+    ]);
+
+    expect(selectMediaFolder).toHaveBeenCalledWith(state.config, collection, entry, imageField);
+  });
+
+  it('should select draft media files from collection when editing a draft', () => {
+    const { selectEditingDraft, selectMediaFolder } = require('../../reducers/entries');
+
+    selectEditingDraft.mockReturnValue(true);
+    selectMediaFolder.mockReturnValue('/static/images/posts');
+
+    const imageField = fromJS({ name: 'image' });
+    const collection = fromJS({ fields: [imageField] });
+    const entry = fromJS({
+      collection: 'posts',
+      mediaFiles: [
+        { id: 1, path: '/static/images/posts/logos/logo.png' },
+        { id: 2, path: '/static/images/posts/general/image.png' },
+        { id: 3, path: '/static/images/posts/index.png' },
+      ],
+      data: {},
+    });
+    const state = {
+      config: {},
+      collections: fromJS({ posts: collection }),
+      entryDraft: fromJS({
+        entry,
+      }),
+    };
+
+    expect(selectMediaFiles(state, imageField)).toEqual([
+      { id: 3, key: 3, path: '/static/images/posts/index.png' },
+    ]);
+
+    expect(selectMediaFolder).toHaveBeenCalledWith(state.config, collection, entry, imageField);
+  });
+
+  it('should select global media files when not editing a draft', () => {
+    const { selectEditingDraft } = require('../../reducers/entries');
+
+    selectEditingDraft.mockReturnValue(false);
+
+    const state = {
+      mediaLibrary: Map({ files: [{ id: 1 }] }),
+    };
+
+    expect(selectMediaFiles(state)).toEqual([{ id: 1 }]);
+  });
+
+  it('should select global media files when not using asset store integration', () => {
+    const { selectIntegration } = require('../../reducers');
+
+    selectIntegration.mockReturnValue({});
+
+    const state = {
+      mediaLibrary: Map({ files: [{ id: 1 }] }),
+    };
+
+    expect(selectMediaFiles(state)).toEqual([{ id: 1 }]);
+  });
+
+  it('should return media file by path', () => {
+    const { selectEditingDraft } = require('../../reducers/entries');
+
+    selectEditingDraft.mockReturnValue(false);
+
+    const state = {
+      mediaLibrary: Map({ files: [{ id: 1, path: 'path' }] }),
+    };
+
+    expect(selectMediaFileByPath(state, 'path')).toEqual({ id: 1, path: 'path' });
+  });
+
+  it('should return media display URL state', () => {
+    const state = {
+      mediaLibrary: fromJS({ displayURLs: { id: { url: 'url' } } }),
+    };
+
+    expect(selectMediaDisplayURL(state, 'id')).toEqual(Map({ url: 'url' }));
+  });
+});

package/src/reducers/__tests__/medias.spec.ts

@@ -0,0 +1,49 @@
+import {
+  addAssets,
+  addAsset,
+  removeAsset,
+  loadAssetRequest,
+  loadAssetSuccess,
+  loadAssetFailure,
+} from '../../actions/media';
+import reducer from '../medias';
+import { createAssetProxy } from '../../valueObjects/AssetProxy';
+
+describe('medias', () => {
+  const asset = createAssetProxy({ url: 'url', path: 'path' });
+
+  it('should add assets', () => {
+    expect(reducer({}, addAssets([asset]))).toEqual({
+      path: { asset, isLoading: false, error: null },
+    });
+  });
+
+  it('should add asset', () => {
+    expect(reducer({}, addAsset(asset))).toEqual({
+      path: { asset, isLoading: false, error: null },
+    });
+  });
+
+  it('should remove asset', () => {
+    expect(
+      reducer({ [asset.path]: { asset, isLoading: false, error: null } }, removeAsset(asset.path)),
+    ).toEqual({});
+  });
+
+  it('should mark asset as loading', () => {
+    expect(reducer({}, loadAssetRequest(asset.path))).toEqual({ path: { isLoading: true } });
+  });
+
+  it('should mark asset as not loading', () => {
+    expect(reducer({}, loadAssetSuccess(asset.path))).toEqual({
+      path: { isLoading: false, error: null },
+    });
+  });
+
+  it('should set loading error', () => {
+    const error = new Error('some error');
+    expect(reducer({}, loadAssetFailure(asset.path, error))).toEqual({
+      path: { isLoading: false, error },
+    });
+  });
+});

package/src/reducers/auth.ts

@@ -0,0 +1,46 @@
+import { produce } from 'immer';
+
+import {
+  AUTH_REQUEST,
+  AUTH_SUCCESS,
+  AUTH_FAILURE,
+  AUTH_REQUEST_DONE,
+  LOGOUT,
+} from '../actions/auth';
+
+import type { User } from 'decap-cms-lib-util';
+import type { AuthAction } from '../actions/auth';
+
+export type Auth = {
+  isFetching: boolean;
+  user: User | undefined;
+  error: string | undefined;
+};
+
+export const defaultState: Auth = {
+  isFetching: false,
+  user: undefined,
+  error: undefined,
+};
+
+const auth = produce((state: Auth, action: AuthAction) => {
+  switch (action.type) {
+    case AUTH_REQUEST:
+      state.isFetching = true;
+      break;
+    case AUTH_SUCCESS:
+      state.user = action.payload;
+      break;
+    case AUTH_FAILURE:
+      state.error = action.payload && action.payload.toString();
+      break;
+    case AUTH_REQUEST_DONE:
+      state.isFetching = false;
+      break;
+    case LOGOUT:
+      state.user = undefined;
+      state.isFetching = false;
+  }
+}, defaultState);
+
+export default auth;