decap-cms-core 3.9.0 → 3.10.0

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/collections.ts

@@ -412,23 +412,46 @@ export function selectDefaultSortableFields(
     defaultSortable = [COMMIT_DATE, ...defaultSortable];
   }
 
-  return defaultSortable as string[];
+  // Return as objects with field property
+  return defaultSortable.map(field => ({ field })) as {
+    field: string;
+    label?: string;
+    default_sort?: boolean | 'asc' | 'desc';
+  }[];
 }
 
 export function selectSortableFields(collection: Collection, t: (key: string) => string) {
   const fields = collection
     .get('sortable_fields')
     .toArray()
-    .map(key => {
+    .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) {
-        return { key, field: { name: key, label: t('collection.defaultFields.updatedOn.label') } };
+        const label = customLabel || t('collection.defaultFields.updatedOn.label');
+        return { key, field: { name: key, label } };
       }
       const field = selectField(collection, key);
       if (key === COMMIT_AUTHOR && !field) {
-        return { key, field: { name: key, label: t('collection.defaultFields.author.label') } };
+        const label = customLabel || t('collection.defaultFields.author.label');
+        return { key, field: { name: key, label } };
+      }
+
+      let fieldObj: Record<string, unknown> | undefined = field?.toJS();
+
+      // If custom label is provided, override the field's label
+      if (fieldObj && customLabel) {
+        fieldObj = { ...fieldObj, label: customLabel };
       }
 
-      return { key, field: field?.toJS() };
+      // If no label exists at all, use the field name
+      if (fieldObj && !fieldObj.label) {
+        fieldObj = { ...fieldObj, label: (fieldObj.name as string) || key };
+      }
+
+      return { key, field: fieldObj };
     })
     .filter(item => !!item.field)
     .map(item => ({ ...item.field, key: item.key }));
@@ -436,6 +459,30 @@ export function selectSortableFields(collection: Collection, t: (key: string) =>
   return fields;
 }
 
+export function selectDefaultSortField(collection: 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: Collection, key: string) {
   if (key === COMMIT_DATE) {
     return 'updatedOn';

package/src/reducers/entries.ts

@@ -78,6 +78,14 @@ let slug: string;
 
 const storageSortKey = 'decap-cms.entries.sort';
 const viewStyleKey = 'decap-cms.entries.viewStyle';
+
+function normalizeDoubleSlashes(path: string) {
+  if (!path) {
+    return path;
+  }
+
+  return path.replace(/([^:]\/)\/+/g, '$1');
+}
 type StorageSortObject = SortObject & { index: number };
 type StorageSort = { [collection: string]: { [key: string]: StorageSortObject } };
 
@@ -785,12 +793,14 @@ export function selectMediaFilePublicPath(
   }
 
   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)) {

package/src/types/redux.ts

@@ -309,6 +309,12 @@ export interface ViewGroup {
   id: string;
 }
 
+export interface SortableField {
+  field: string;
+  label?: string;
+  default_sort?: boolean | 'asc' | 'desc';
+}
+
 export interface CmsCollection {
   name: string;
   label: string;
@@ -348,7 +354,7 @@ export interface CmsCollection {
   path?: string;
   media_folder?: string;
   public_folder?: string;
-  sortable_fields?: string[];
+  sortable_fields?: (string | SortableField)[];
   view_filters?: ViewFilter[];
   view_groups?: ViewGroup[];
   i18n?: boolean | CmsI18nConfig;
@@ -356,7 +362,7 @@ export interface CmsCollection {
   /**
    * @deprecated Use sortable_fields instead
    */
-  sortableFields?: string[];
+  sortableFields?: (string | SortableField)[];
 }
 
 export interface CmsBackend {
@@ -635,7 +641,7 @@ type CollectionObject = {
   slug?: string;
   label_singular?: string;
   label: string;
-  sortable_fields: List<string>;
+  sortable_fields: List<StaticallyTypedRecord<SortableField>>;
   view_filters: List<StaticallyTypedRecord<ViewFilter>>;
   view_groups: List<StaticallyTypedRecord<ViewGroup>>;
   nested?: Nested;