decap-cms-core 3.8.1 → 3.10.0

package/dist/esm/lib/pagination.js

@@ -0,0 +1,68 @@
+/**
+ * Pagination Utilities
+ *
+ * This module provides helpers for determining if pagination is enabled for a collection,
+ * and for retrieving the effective pagination configuration (page size, enabled flag).
+ *
+ * Principles:
+ * - Pagination can be enabled/disabled per collection or globally via config.
+ * - If sorting, filtering, or grouping is active, pagination is handled client-side (all entries loaded).
+ * - If none are active, server-side pagination is used (only a page of entries loaded at a time).
+ * - The effective page size is determined by collection config, then global config, then a default.
+ *
+ * Usage:
+ * - Use isPaginationEnabled(collection, config) to check if pagination should be active.
+ * - Use getPaginationConfig(collection, config) to get the effective page size and enabled flag.
+ */
+import { getValue, isImmutableMap } from './immutableHelpers';
+const DEFAULT_PER_PAGE = 100;
+export function isPaginationEnabled(collection, globalConfig) {
+  const pagination = isImmutableMap(collection) ? collection.get('pagination') : collection.pagination;
+  if (typeof pagination !== 'undefined') {
+    if (typeof pagination === 'boolean') return pagination;
+    if (pagination && typeof pagination === 'object') {
+      const enabled = getValue(pagination, 'enabled');
+      return enabled !== false;
+    }
+    return false;
+  }
+  if (globalConfig?.pagination) {
+    if (typeof globalConfig.pagination === 'boolean') return globalConfig.pagination;
+    if (typeof globalConfig.pagination === 'object') {
+      const enabled = getValue(globalConfig.pagination, 'enabled');
+      return enabled !== false;
+    }
+  }
+  return false;
+}
+export function getPaginationConfig(collection, globalConfig) {
+  const defaults = {
+    enabled: false,
+    per_page: DEFAULT_PER_PAGE
+  };
+  if (globalConfig?.pagination) {
+    if (typeof globalConfig.pagination === 'boolean') {
+      defaults.enabled = globalConfig.pagination;
+    } else if (typeof globalConfig.pagination === 'object') {
+      const enabled = getValue(globalConfig.pagination, 'enabled');
+      defaults.enabled = enabled !== false;
+      const perPage = getValue(globalConfig.pagination, 'per_page');
+      defaults.per_page = typeof perPage === 'number' ? perPage : defaults.per_page;
+    }
+  }
+  const pagination = isImmutableMap(collection) ? collection.get('pagination') : collection.pagination;
+  if (pagination === true) {
+    return {
+      enabled: true,
+      per_page: defaults.per_page
+    };
+  } else if (typeof pagination === 'object' && pagination !== null) {
+    const perPage = getValue(pagination, 'per_page');
+    const enabled = getValue(pagination, 'enabled');
+    return {
+      enabled: enabled !== false,
+      per_page: typeof perPage === 'number' ? perPage : defaults.per_page
+    };
+  }
+  return defaults;
+}

package/dist/esm/reducers/collections.js

@@ -305,32 +305,58 @@ export function selectDefaultSortableFields(collection, backend, hasIntegration)
     // always have commit date by default
     defaultSortable = [COMMIT_DATE, ...defaultSortable];
   }
-  return defaultSortable;
+
+  // Return as objects with field property
+  return defaultSortable.map(field => ({
+    field
+  }));
 }
 export function selectSortableFields(collection, t) {
-  const fields = collection.get('sortable_fields').toArray().map(key => {
+  const fields = collection.get('sortable_fields').toArray().map(sortableField => {
+    // Extract the field name and custom label from the sortable field object
+    const key = sortableField.get('field');
+    const customLabel = sortableField.get('label');
     if (key === COMMIT_DATE) {
+      const label = customLabel || t('collection.defaultFields.updatedOn.label');
       return {
         key,
         field: {
           name: key,
-          label: t('collection.defaultFields.updatedOn.label')
+          label
         }
       };
     }
     const field = selectField(collection, key);
     if (key === COMMIT_AUTHOR && !field) {
+      const label = customLabel || t('collection.defaultFields.author.label');
       return {
         key,
         field: {
           name: key,
-          label: t('collection.defaultFields.author.label')
+          label
         }
       };
     }
+    let fieldObj = field?.toJS();
+
+    // If custom label is provided, override the field's label
+    if (fieldObj && customLabel) {
+      fieldObj = {
+        ...fieldObj,
+        label: customLabel
+      };
+    }
+
+    // If no label exists at all, use the field name
+    if (fieldObj && !fieldObj.label) {
+      fieldObj = {
+        ...fieldObj,
+        label: fieldObj.name || key
+      };
+    }
     return {
       key,
-      field: field?.toJS()
+      field: fieldObj
     };
   }).filter(item => !!item.field).map(item => ({
     ...item.field,
@@ -338,6 +364,29 @@ export function selectSortableFields(collection, t) {
   }));
   return fields;
 }
+export function selectDefaultSortField(collection) {
+  const sortableFields = collection.get('sortable_fields').toArray();
+  const defaultField = sortableFields.find(field => field.get('default_sort') !== undefined);
+  if (!defaultField) {
+    return null;
+  }
+  const fieldName = defaultField.get('field');
+  const defaultSortValue = defaultField.get('default_sort');
+
+  // Determine direction based on default_sort value
+  let direction;
+  if (defaultSortValue === true || defaultSortValue === 'asc') {
+    direction = 'asc';
+  } else if (defaultSortValue === 'desc') {
+    direction = 'desc';
+  } else {
+    direction = 'asc'; // fallback
+  }
+  return {
+    field: fieldName,
+    direction
+  };
+}
 export function selectSortDataPath(collection, key) {
   if (key === COMMIT_DATE) {
     return 'updatedOn';

package/dist/esm/reducers/entries.js

@@ -25,6 +25,12 @@ let page;
 let slug;
 const storageSortKey = 'decap-cms.entries.sort';
 const viewStyleKey = 'decap-cms.entries.viewStyle';
+function normalizeDoubleSlashes(path) {
+  if (!path) {
+    return path;
+  }
+  return path.replace(/([^:]\/)\/+/g, '$1');
+}
 const loadSort = once(() => {
   const sortString = localStorage.getItem(storageSortKey);
   if (sortString) {
@@ -429,7 +435,6 @@ export function selectEntriesLoaded(state, collection) {
 export function selectIsFetching(state, collection) {
   return state.getIn(['pages', collection, 'isFetching'], false);
 }
-const DRAFT_MEDIA_FILES = 'DRAFT_MEDIA_FILES';
 function getFileField(collectionFiles, slug) {
   const file = collectionFiles.find(f => f?.get('name') === slug);
   return file;
@@ -528,7 +533,7 @@ export function selectMediaFolder(config, collection, entryMap, field) {
       mediaFolder = join(folder);
     } else {
       const entryPath = entryMap?.get('path');
-      mediaFolder = entryPath ? join(dirname(entryPath), folder) : join(collection.get('folder'), DRAFT_MEDIA_FILES);
+      mediaFolder = entryPath ? join(dirname(entryPath), folder) : collection.get('folder');
     }
   }
   return trim(mediaFolder, '/');
@@ -545,10 +550,10 @@ export function selectMediaFilePublicPath(config, collection, mediaPath, entryMa
     return mediaPath;
   }
   const name = 'public_folder';
-  let publicFolder = config[name];
+  let publicFolder = normalizeDoubleSlashes(config[name]);
   const customFolder = hasCustomFolder(name, collection, entryMap?.get('slug'), field);
   if (customFolder) {
-    publicFolder = evaluateFolder(name, config, collection, entryMap, field);
+    publicFolder = normalizeDoubleSlashes(evaluateFolder(name, config, collection, entryMap, field));
   }
   if (isAbsolutePath(publicFolder)) {
     return joinUrlPath(publicFolder, basename(mediaPath));

package/index.d.ts

@@ -133,6 +133,8 @@ declare module 'decap-cms-core' {
     default?: any;
 
     allow_add?: boolean;
+    allow_remove?: boolean;
+    allow_reorder?: boolean;
     collapsed?: boolean;
     summary?: string;
     minimize_collapsed?: boolean;
@@ -290,6 +292,12 @@ declare module 'decap-cms-core' {
     pattern?: string;
   }
 
+  export interface SortableField {
+    field: string;
+    label?: string;
+    default_sort?: boolean | 'asc' | 'desc';
+  }
+
   export interface CmsCollection {
     name: string;
     label: string;
@@ -330,7 +338,7 @@ declare module 'decap-cms-core' {
     path?: string;
     media_folder?: string;
     public_folder?: string;
-    sortable_fields?: string[];
+    sortable_fields?: (string | SortableField)[];
     view_filters?: ViewFilter[];
     view_groups?: ViewGroup[];
     i18n?: boolean | CmsI18nConfig;
@@ -338,7 +346,7 @@ declare module 'decap-cms-core' {
     /**
      * @deprecated Use sortable_fields instead
      */
-    sortableFields?: string[];
+    sortableFields?: (string | SortableField)[];
   }
 
   export interface CmsBackend {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "decap-cms-core",
   "description": "Decap CMS core application, see decap-cms package for the main distribution.",
-  "version": "3.8.1",
+  "version": "3.10.0",
   "repository": "https://github.com/decaporg/decap-cms/tree/main/packages/decap-cms-core",
   "bugs": "https://github.com/decaporg/decap-cms/issues",
   "module": "dist/esm/index.js",
@@ -28,7 +28,6 @@
     "@reduxjs/toolkit": "^1.9.1",
     "@vercel/stega": "^0.1.2",
     "buffer": "^6.0.3",
-    "clean-stack": "^5.2.0",
     "copy-text-to-clipboard": "^3.0.0",
     "dayjs": "^1.11.10",
     "deepmerge": "^4.2.2",
@@ -100,5 +99,5 @@
   "browser": {
     "path": "path-browserify"
   },
-  "gitHead": "899dba82d1f396260e0f84c6977c1d2aee809b59"
+  "gitHead": "0c1b7c7d63ba6ddb3de3692fbb6b16ac6ebb44d5"
 }

package/src/actions/__tests__/config.spec.js

@@ -1,5 +1,5 @@
 import { stripIndent } from 'common-tags';
-import { dump } from 'js-yaml';
+import { stringify } from 'yaml';
 
 import {
   loadConfig,
@@ -480,7 +480,7 @@ describe('config', () => {
       ).toEqual({
         collections: [
           {
-            sortable_fields: ['title'],
+            sortable_fields: [{ field: 'title', default_sort: undefined }],
             folder: 'src',
             type: 'folder_based_collection',
             view_filters: [],
@@ -934,7 +934,7 @@ describe('config', () => {
 
       global.fetch.mockResolvedValue({
         status: 200,
-        text: () => Promise.resolve(dump({ backend: { repo: 'test-repo' } })),
+        text: () => Promise.resolve(stringify({ backend: { repo: 'test-repo' } })),
         headers: new Headers(),
       });
       await loadConfig()(dispatch);
@@ -962,7 +962,7 @@ describe('config', () => {
       document.querySelector.mockReturnValue({ type: 'text/yaml', href: 'custom-config.yml' });
       global.fetch.mockResolvedValue({
         status: 200,
-        text: () => Promise.resolve(dump({ backend: { repo: 'github' } })),
+        text: () => Promise.resolve(stringify({ backend: { repo: 'github' } })),
         headers: new Headers(),
       });
       await loadConfig()(dispatch);

package/src/actions/config.ts

@@ -171,6 +171,20 @@ function hasIntegration(config: CmsConfig, collection: CmsCollection) {
   return !!integration;
 }
 
+function normalizeSortableFields(
+  sortableFields: (
+    | string
+    | { field: string; label?: string; default_sort?: boolean | 'asc' | 'desc' }
+  )[],
+) {
+  return sortableFields.map(field => {
+    if (typeof field === 'string') {
+      return { field, default_sort: undefined };
+    }
+    return field;
+  });
+}
+
 export function normalizeConfig(config: CmsConfig) {
   const { collections = [] } = config;
 
@@ -200,6 +214,14 @@ export function normalizeConfig(config: CmsConfig) {
       );
     }
 
+    // Normalize sortable_fields to consistent object format
+    if (normalizedCollection.sortable_fields) {
+      normalizedCollection = {
+        ...normalizedCollection,
+        sortable_fields: normalizeSortableFields(normalizedCollection.sortable_fields),
+      };
+    }
+
     return normalizedCollection;
   });
 

package/src/actions/entries.ts

@@ -3,7 +3,7 @@ import isEqual from 'lodash/isEqual';
 import { Cursor } from 'decap-cms-lib-util';
 
 import { selectCollectionEntriesCursor } from '../reducers/cursors';
-import { selectFields, updateFieldByKey } from '../reducers/collections';
+import { selectFields, updateFieldByKey, selectDefaultSortField } from '../reducers/collections';
 import { selectIntegration, selectPublishedSlugs } from '../reducers';
 import { getIntegrationProvider } from '../integrations';
 import { currentBackend } from '../backend';
@@ -579,11 +579,21 @@ export function loadEntries(collection: Collection, page = 0) {
     }
     const state = getState();
     const sortFields = selectEntriesSortFields(state.entries, collection.get('name'));
+
+    // If user has already set a sort, use it
     if (sortFields && sortFields.length > 0) {
       const field = sortFields[0];
       return dispatch(sortByField(collection, field.get('key'), field.get('direction')));
     }
 
+    // Otherwise, check for a default sort field in the collection configuration
+    const defaultSort = selectDefaultSortField(collection);
+    if (defaultSort) {
+      const direction =
+        defaultSort.direction === 'desc' ? SortDirection.Descending : SortDirection.Ascending;
+      return dispatch(sortByField(collection, defaultSort.field, direction));
+    }
+
     const backend = currentBackend(state.config);
     const integration = selectIntegration(state, collection.get('name'), 'listEntries');
     const provider = integration

package/src/components/UI/ErrorBoundary.js

@@ -7,7 +7,6 @@ import truncate from 'lodash/truncate';
 import copyToClipboard from 'copy-text-to-clipboard';
 import { localForage } from 'decap-cms-lib-util';
 import { buttons, colors } from 'decap-cms-ui-default';
-import cleanStack from 'clean-stack';
 
 const ISSUE_URL = 'https://github.com/decaporg/decap-cms/issues/new?';
 
@@ -145,7 +144,7 @@ export class ErrorBoundary extends React.Component {
     console.error(error);
     return {
       hasError: true,
-      errorMessage: cleanStack(error.stack, { basePath: window.location.origin || '' }),
+      errorMessage: error.stack || error.toString(),
       errorTitle: error.toString(),
     };
   }

package/src/constants/__tests__/configSchema.spec.js

@@ -216,6 +216,90 @@ describe('config', () => {
       }).toThrowError("'collections[0]' must NOT be valid");
     });
 
+    it('should allow sortable_fields to have object format with field property', () => {
+      expect(() => {
+        validateConfig(
+          merge({}, validConfig, {
+            collections: [{ sortable_fields: [{ field: 'title' }] }],
+          }),
+        );
+      }).not.toThrow();
+    });
+
+    it('should allow sortable_fields with default_sort as boolean', () => {
+      expect(() => {
+        validateConfig(
+          merge({}, validConfig, {
+            collections: [{ sortable_fields: [{ field: 'title', default_sort: true }] }],
+          }),
+        );
+      }).not.toThrow();
+    });
+
+    it('should allow sortable_fields with default_sort as asc/desc', () => {
+      expect(() => {
+        validateConfig(
+          merge({}, validConfig, {
+            collections: [{ sortable_fields: ['title', { field: 'date', default_sort: 'desc' }] }],
+          }),
+        );
+      }).not.toThrow();
+    });
+
+    it('should allow sortable_fields with custom label', () => {
+      expect(() => {
+        validateConfig(
+          merge({}, validConfig, {
+            collections: [{ sortable_fields: [{ field: 'date', label: 'Publish Date' }] }],
+          }),
+        );
+      }).not.toThrow();
+    });
+
+    it('should allow sortable_fields with label and default_sort', () => {
+      expect(() => {
+        validateConfig(
+          merge({}, validConfig, {
+            collections: [
+              {
+                sortable_fields: [
+                  'title',
+                  { field: 'date', label: 'Publish Date', default_sort: 'desc' },
+                ],
+              },
+            ],
+          }),
+        );
+      }).not.toThrow();
+    });
+
+    it('should allow mixed string and object format in sortable_fields', () => {
+      expect(() => {
+        validateConfig(
+          merge({}, validConfig, {
+            collections: [{ sortable_fields: ['title', { field: 'date', default_sort: true }] }],
+          }),
+        );
+      }).not.toThrow();
+    });
+
+    it('should throw if more than one sortable field has default_sort property', () => {
+      expect(() => {
+        validateConfig(
+          merge({}, validConfig, {
+            collections: [
+              {
+                sortable_fields: [
+                  { field: 'title', default_sort: true },
+                  { field: 'date', default_sort: true },
+                ],
+              },
+            ],
+          }),
+        );
+      }).toThrowError('only one sortable field can have the default_sort property');
+    });
+
     it('should throw if collection names are not unique', () => {
       expect(() => {
         validateConfig(

package/src/constants/configSchema.js

@@ -253,7 +253,21 @@ function getConfigSchema() {
             sortable_fields: {
               type: 'array',
               items: {
-                type: 'string',
+                oneOf: [
+                  { type: 'string' },
+                  {
+                    type: 'object',
+                    properties: {
+                      field: { type: 'string' },
+                      label: { type: 'string' },
+                      default_sort: {
+                        oneOf: [{ type: 'boolean' }, { type: 'string', enum: ['asc', 'desc'] }],
+                      },
+                    },
+                    required: ['field'],
+                    additionalProperties: false,
+                  },
+                ],
               },
             },
             sortableFields: {
@@ -405,4 +419,23 @@ export function validateConfig(config) {
     console.error('Config Errors', errors);
     throw new ConfigError(errors);
   }
+
+  // Custom validation: only one sortable field can have default_sort property
+  if (config.collections) {
+    config.collections.forEach((collection, index) => {
+      if (collection.sortable_fields) {
+        const defaultFields = collection.sortable_fields.filter(
+          field => typeof field === 'object' && field.default_sort !== undefined,
+        );
+        if (defaultFields.length > 1) {
+          const error = {
+            instancePath: `/collections/${index}/sortable_fields`,
+            message: 'only one sortable field can have the default_sort property',
+          };
+          console.error('Config Errors', [error]);
+          throw new ConfigError([error]);
+        }
+      }
+    });
+  }
 }

package/src/lib/__tests__/formatters.spec.js

@@ -274,8 +274,8 @@ describe('formatters', () => {
   };
 
   describe('slugFormatter', () => {
-    const date = new Date('2020-01-01');
-    jest.spyOn(global, 'Date').mockImplementation(() => date);
+    const date = new Date('2020-01-01').valueOf();
+    Date.now = jest.spyOn(Date, 'now').mockImplementation(() => date);
 
     const { selectIdentifier } = require('../../reducers/collections');
 
@@ -312,6 +312,34 @@ describe('formatters', () => {
       ).toBe('entry-slug');
     });
 
+    it('should see date filters applied to date from entry if it exists', () => {
+      const { selectInferredField } = require('../../reducers/collections');
+      selectInferredField.mockReturnValue('date');
+      const entryDate = new Date('2026-10-20');
+
+      expect(
+        slugFormatter(
+          Map({ slug: '{{year}}-{{month}}-{{day}}-{{title}}' }),
+          Map({ date: entryDate, title: 'post title' }),
+          slugConfig,
+        ),
+      ).toBe('2026-10-20-post-title');
+    });
+
+    it('should see date filters applied to publishDate from entry if it exists', () => {
+      const { selectInferredField } = require('../../reducers/collections');
+      selectInferredField.mockReturnValue('publishDate');
+      const entryDate = new Date('2026-10-20');
+
+      expect(
+        slugFormatter(
+          Map({ slug: '{{year}}-{{month}}-{{day}}-{{title}}' }),
+          Map({ publishDate: entryDate, title: 'post title' }),
+          slugConfig,
+        ),
+      ).toBe('2026-10-20-post-title');
+    });
+
     it('should return slug', () => {
       selectIdentifier.mockReturnValueOnce('title');
 

package/src/lib/formatters.ts

@@ -21,6 +21,7 @@ import type { Map } from 'immutable';
 const {
   compileStringTemplate,
   parseDateFromEntry,
+  parseDateFromEntryData,
   SLUG_MISSING_REQUIRED_DATE,
   keyToPathArray,
   addFileTemplateFields,
@@ -129,7 +130,11 @@ export function slugFormatter(
   }
 
   const processSegment = getProcessSegment(slugConfig);
-  const date = new Date();
+  const date =
+    parseDateFromEntryData(
+      entryData as unknown as Map<string, unknown>,
+      selectInferredField(collection, 'date'),
+    ) || new Date(Date.now());
   const slug = compileStringTemplate(slugTemplate, date, identifier, entryData, processSegment);
 
   if (!collection.has('path')) {

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

@@ -11,6 +11,7 @@ import collections, {
   getFieldsNames,
   selectField,
   updateFieldByKey,
+  selectInferredField,
 } from '../collections';
 import { FILES, FOLDER } from '../../constants/collectionTypes';
 
@@ -568,4 +569,42 @@ describe('collections', () => {
       );
     });
   });
+
+  describe("selectInferredField(collection, 'date')", () => {
+    it('should return publishDate if set', () => {
+      const collection = fromJS({
+        fields: [{ name: 'title' }, { name: 'publishDate', widget: 'datetime' }],
+      });
+
+      expect(selectInferredField(collection, 'date')).toEqual('publishDate');
+    });
+
+    it('should return publish_date if set', () => {
+      const collection = fromJS({
+        fields: [{ name: 'title' }, { name: 'publish_date', widget: 'datetime' }],
+      });
+
+      expect(selectInferredField(collection, 'date')).toEqual('publish_date');
+    });
+
+    it('should return date if set', () => {
+      const collection = fromJS({
+        fields: [{ name: 'title' }, { name: 'date', widget: 'datetime' }],
+      });
+
+      expect(selectInferredField(collection, 'date')).toEqual('date');
+    });
+
+    it('should return first date field if multiple synonyms are present', () => {
+      const collection = fromJS({
+        fields: [
+          { name: 'title' },
+          { name: 'publishDate', widget: 'datetime' },
+          { name: 'date', widget: 'datetime' },
+        ],
+      });
+
+      expect(selectInferredField(collection, 'date')).toEqual('publishDate');
+    });
+  });
 });

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

@@ -85,7 +85,7 @@ describe('entries', () => {
       ).toEqual('static/media');
     });
 
-    it('should return draft media folder when collection specifies media_folder and entry is undefined', () => {
+    it('should return collection folder when collection specifies media_folder and entry is undefined', () => {
       expect(
         selectMediaFolder(
           { media_folder: 'static/media' },
@@ -93,7 +93,7 @@ describe('entries', () => {
           undefined,
           undefined,
         ),
-      ).toEqual('posts/DRAFT_MEDIA_FILES');
+      ).toEqual('posts');
     });
 
     it('should return relative media folder when collection specifies media_folder and entry path is not null', () => {
@@ -364,7 +364,7 @@ describe('entries', () => {
           'image.png',
           undefined,
         ),
-      ).toBe('posts/DRAFT_MEDIA_FILES/image.png');
+      ).toBe('posts/image.png');
     });
 
     it('should handle relative media_folder', () => {