decap-cms-core 3.12.0 → 3.14.0

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

@@ -295,8 +295,8 @@ describe('formatters', () => {
   };
 
   describe('slugFormatter', () => {
-    const date = new Date('2020-01-01').valueOf();
-    Date.now = jest.spyOn(Date, 'now').mockImplementation(() => date);
+    const date = new Date('2020-01-01T13:28:27.679Z').valueOf();
+    jest.spyOn(Date, 'now').mockImplementation(() => date);
 
     const { selectIdentifier } = require('../../reducers/collections');
 
@@ -333,10 +333,22 @@ describe('formatters', () => {
       ).toBe('entry-slug');
     });
 
+    it('should allow filters in slug templates', () => {
+      selectIdentifier.mockReturnValueOnce('published');
+
+      expect(
+        slugFormatter(
+          Map({ slug: "{{published | date('MM-DD')}}" }),
+          Map({ title: 'Post Title', published: new Date(date) }),
+          slugConfig,
+        ),
+      ).toBe('01-01');
+    });
+
     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');
+      const entryDate = new Date('2026-10-20T13:28:27.679Z');
 
       expect(
         slugFormatter(
@@ -350,7 +362,7 @@ describe('formatters', () => {
     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');
+      const entryDate = new Date('2026-10-20T13:28:27.679Z');
 
       expect(
         slugFormatter(
@@ -587,6 +599,66 @@ describe('formatters', () => {
         'Collection "posts" configuration error:\n  `preview_path_date_field` must be a field with a valid date. Ignoring `preview_path`.',
       );
     });
+
+    it('should preserve slashes in value when configured', () => {
+      expect(
+        previewUrlFormatter(
+          'https://www.example.com',
+          Map({
+            preview_path: 'prefix/{{value}}',
+            preview_path_preserve_slashes: true,
+          }),
+          'backendSlug',
+          Map({ data: Map({ value: 'nested/value' }) }),
+          slugConfig,
+        ),
+      ).toBe('https://www.example.com/prefix/nested/value');
+    });
+
+    it('should sanitize slashes in value when not configured', () => {
+      expect(
+        previewUrlFormatter(
+          'https://www.example.com',
+          Map({
+            preview_path: 'prefix/{{value}}',
+          }),
+          'backendSlug',
+          Map({ data: Map({ value: 'nested/value' }) }),
+          slugConfig,
+        ),
+      ).toBe('https://www.example.com/prefix/nested-value');
+    });
+
+    it('should preserve slashes in value for nested collections by default', () => {
+      expect(
+        previewUrlFormatter(
+          'https://www.example.com',
+          Map({
+            preview_path: 'prefix/{{value}}',
+            nested: { depth: 10 },
+          }),
+          'backendSlug',
+          Map({ data: Map({ value: 'nested/value' }) }),
+          slugConfig,
+        ),
+      ).toBe('https://www.example.com/prefix/nested/value');
+    });
+
+    it('should sanitize slashes in value for nested collections when explicitly disabled', () => {
+      expect(
+        previewUrlFormatter(
+          'https://www.example.com',
+          Map({
+            preview_path: 'prefix/{{value}}',
+            nested: { depth: 10 },
+            preview_path_preserve_slashes: false,
+          }),
+          'backendSlug',
+          Map({ data: Map({ value: 'nested/value' }) }),
+          slugConfig,
+        ),
+      ).toBe('https://www.example.com/prefix/nested-value');
+    });
   });
 
   describe('summaryFormatter', () => {

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

@@ -200,7 +200,7 @@ describe('registry', () => {
         });
       });
 
-      it(`should return an updated entry's DataMap`, async () => {
+      it(`should return the complete updated entry object`, async () => {
         const { registerEventListener, invokeEvent } = require('../registry');
 
         const event = 'preSave';
@@ -233,7 +233,7 @@ describe('registry', () => {
         expect(handler1).toHaveBeenCalledWith(data, options);
         expect(handler2).toHaveBeenCalledWith(dataAfterFirstHandlerExecution, options);
 
-        expect(result).toEqual(dataAfterSecondHandlerExecution.entry.get('data'));
+        expect(result).toEqual(dataAfterSecondHandlerExecution.entry);
       });
 
       it('should allow multiple events to not return a value', async () => {
@@ -254,7 +254,7 @@ describe('registry', () => {
 
         expect(handler1).toHaveBeenCalledWith(data, options);
         expect(handler2).toHaveBeenCalledWith(data, options);
-        expect(result).toEqual(data.entry.get('data'));
+        expect(result).toEqual(data.entry);
       });
     });
   });

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

@@ -125,6 +125,13 @@ describe('sanitizeSlug', () => {
       'test_test',
     );
   });
+
+  it('preserves slashes when requested', () => {
+    const input = '/this-is-a/nested/page';
+
+    expect(sanitizeSlug(input, slugConfig, false)).toEqual('this-is-a-nested-page');
+    expect(sanitizeSlug(input, slugConfig, true)).toEqual('this-is-a/nested/page');
+  });
 });
 
 describe('sanitizeChar', () => {

package/src/lib/formatters.ts

@@ -120,11 +120,19 @@ export function prepareSlug(slug: string) {
   );
 }
 
-export function getProcessSegment(slugConfig?: CmsSlug, ignoreValues?: string[]) {
+export function getProcessSegment(
+  slugConfig?: CmsSlug,
+  ignoreValues?: string[],
+  preserveSlashes?: boolean,
+) {
   return (value: string) =>
     ignoreValues && ignoreValues.includes(value)
       ? value
-      : flow([value => String(value), prepareSlug, partialRight(sanitizeSlug, slugConfig)])(value);
+      : flow([
+          value => String(value),
+          prepareSlug,
+          partialRight(sanitizeSlug, slugConfig, preserveSlashes),
+        ])(value);
 }
 
 export function slugFormatter(
@@ -205,19 +213,21 @@ export function previewUrlFormatter(
   fields = addFileTemplateFields(entry.get('path'), fields, collection.get('folder'));
   const dateFieldName = getDateField() || selectInferredField(collection, 'date');
   const date = parseDateFromEntry(entry as unknown as Map<string, unknown>, dateFieldName);
+  const previewPathPreserveSlashes = collection.get('preview_path_preserve_slashes');
+  const preserveSlashes = !!(previewPathPreserveSlashes ?? collection.has('nested'));
 
   // Prepare and sanitize slug variables only, leave the rest of the
   // `preview_path` template as is.
-  const processSegment = getProcessSegment(slugConfig, [fields.get('dirname')]);
+  const processSegment = getProcessSegment(slugConfig, [fields.get('dirname')], preserveSlashes);
   let compiledPath;
 
   try {
     compiledPath = compileStringTemplate(pathTemplate, date, slug, fields, processSegment);
-  } catch (err) {
+  } catch (err: unknown) {
     // Print an error and ignore `preview_path` if both:
     //   1. Date is invalid (according to DayJs), and
     //   2. A date expression (eg. `{{year}}`) is used in `preview_path`
-    if (err.name === SLUG_MISSING_REQUIRED_DATE) {
+    if (err instanceof Error && err.name === SLUG_MISSING_REQUIRED_DATE) {
       console.error(stripIndent`
         Collection "${collection.get('name')}" configuration error:
           \`preview_path_date_field\` must be a field with a valid date. Ignoring \`preview_path\`.

package/src/lib/registry.js

@@ -257,7 +257,10 @@ export async function invokeEvent({ name, data }) {
       _data = { ...data, entry };
     }
   }
-  return _data.entry.get('data');
+  // Return the full entry object with all metadata (slug, path, meta, etc.)
+  // rather than just the data payload. Callers like invokePreSaveEvent expect
+  // the complete entry object to be preserved through the event handler chain.
+  return _data.entry;
 }
 
 export function removeEventListener({ name, handler }) {

package/src/lib/urlHelper.ts

@@ -51,7 +51,14 @@ function validIRIChar(char: string) {
   return uriChars.test(char) || ucsChars.test(char);
 }
 
-export function getCharReplacer(encoding: string, replacement: string) {
+export function getCharReplacer(
+  encoding: string,
+  options: {
+    replacement: NonNullable<CmsSlug['sanitize_replacement']>;
+    preserveSlashes?: boolean;
+  },
+) {
+  const { replacement, preserveSlashes } = options;
   let validChar: (char: string) => boolean;
 
   if (encoding === 'unicode') {
@@ -67,14 +74,24 @@ export function getCharReplacer(encoding: string, replacement: string) {
     throw new Error('The replacement character(s) (options.replacement) is itself unsafe.');
   }
 
-  return (char: string) => (validChar(char) ? char : replacement);
+  return (char: string, i = 0, arr: string[] = [char]) => {
+    if (preserveSlashes && char === '/' && i !== 0 && i !== arr.length - 1) {
+      return char;
+    }
+
+    return validChar(char) ? char : replacement;
+  };
 }
 // `sanitizeURI` does not actually URI-encode the chars (that is the browser's and server's job), just removes the ones that are not allowed.
 export function sanitizeURI(
   str: string,
-  options?: { replacement: CmsSlug['sanitize_replacement']; encoding: CmsSlug['encoding'] },
+  options?: {
+    replacement: CmsSlug['sanitize_replacement'];
+    encoding: CmsSlug['encoding'];
+    preserveSlashes?: boolean;
+  },
 ) {
-  const { replacement = '', encoding = 'unicode' } = options || {};
+  const { replacement = '', encoding = 'unicode', preserveSlashes } = options || {};
 
   if (!isString(str)) {
     throw new Error('The input slug must be a string.');
@@ -85,15 +102,15 @@ export function sanitizeURI(
 
   // `Array.from` must be used instead of `String.split` because
   //   `split` converts things like emojis into UTF-16 surrogate pairs.
-  return Array.from(str).map(getCharReplacer(encoding, replacement)).join('');
+  return Array.from(str).map(getCharReplacer(encoding, { replacement, preserveSlashes })).join('');
 }
 
 export function sanitizeChar(char: string, options?: CmsSlug) {
   const { encoding = 'unicode', sanitize_replacement: replacement = '' } = options || {};
-  return getCharReplacer(encoding, replacement)(char);
+  return getCharReplacer(encoding, { replacement })(char);
 }
 
-export function sanitizeSlug(str: string, options?: CmsSlug) {
+export function sanitizeSlug(str: string, options?: CmsSlug, preserveSlashes?: boolean) {
   if (!isString(str)) {
     throw new Error('The input slug must be a string.');
   }
@@ -106,8 +123,15 @@ export function sanitizeSlug(str: string, options?: CmsSlug) {
 
   const sanitizedSlug = flow([
     ...(stripDiacritics ? [diacritics.remove] : []),
-    partialRight(sanitizeURI, { replacement, encoding }),
-    partialRight(sanitizeFilename, { replacement }),
+    partialRight(sanitizeURI, { replacement, encoding, preserveSlashes }),
+    preserveSlashes
+      ? (slug: string) =>
+          slug
+            .split('/')
+            .filter(Boolean)
+            .map(part => sanitizeFilename(part, { replacement }))
+            .join('/')
+      : partialRight(sanitizeFilename, { replacement }),
   ])(str);
 
   // Remove any doubled or leading/trailing replacement characters (that were added in the sanitizers).

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

@@ -195,4 +195,121 @@ describe('entryDraft reducer', () => {
       });
     });
   });
+
+  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();
+    });
+
+    it('should preserve non-latin characters in generated filename', () => {
+      const collection = fromJS({
+        folder: '_pages',
+        extension: 'md',
+        meta: { path: { label: 'Path', widget: 'string' } },
+      });
+      const entryDraft = fromJS({
+        entry: {
+          newRecord: true,
+          data: { title: '日本語のタイトル' },
+          meta: { path: 'blog' },
+        },
+      });
+
+      const result = selectCustomPath(collection, entryDraft);
+      expect(result).toBe('_pages/blog/日本語のタイトル.md');
+    });
+  });
 });

package/src/reducers/entryDraft.js

@@ -1,8 +1,9 @@
 import { Map, List, fromJS } from 'immutable';
 import { v4 as uuid } from 'uuid';
 import get from 'lodash/get';
-import { join } from 'path';
+import { join, basename } from 'path';
 
+import { sanitizeSlug } from '../lib/urlHelper';
 import {
   DRAFT_CREATE_FROM_ENTRY,
   DRAFT_CREATE_EMPTY,
@@ -204,15 +205,54 @@ function entryDraftReducer(state = Map(), action) {
   }
 }
 
+function cleanTitleForFilename(title) {
+  if (!title) return 'untitled';
+
+  const cleanedTitle = sanitizeSlug(title.toString().toLowerCase().trim(), {
+    sanitize_replacement: '-',
+    encoding: 'unicode',
+  });
+
+  return cleanedTitle || 'untitled';
+}
+
 export function selectCustomPath(collection, entryDraft) {
   if (!selectHasMetaPath(collection)) {
     return;
   }
   const meta = entryDraft.getIn(['entry', 'meta']);
   const path = meta && meta.get('path');
-  const indexFile = get(collection.toJS(), ['meta', 'path', 'index_file']);
+
+  if (!path) {
+    return;
+  }
+
   const extension = selectFolderEntryExtension(collection);
-  const customPath = path && join(collection.get('folder'), path, `${indexFile}.${extension}`);
+  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 currentFilename = basename(currentPath, `.${extension}`);
+    filename = currentFilename;
+  }
+
+  const customPath = join(collection.get('folder'), path, `${filename}.${extension}`);
   return customPath;
 }
 

package/src/types/redux.ts

@@ -185,6 +185,21 @@ export interface CmsFieldMarkdown {
   editorComponents?: string[];
 }
 
+export interface CmsFieldRichText {
+  widget: 'richtext';
+  default?: string;
+
+  minimal?: boolean;
+  buttons?: CmsMarkdownWidgetButton[];
+  editor_components?: string[];
+  modes?: ('raw' | 'rich_text')[];
+
+  /**
+   * @deprecated Use editor_components instead
+   */
+  editorComponents?: string[];
+}
+
 export interface CmsFieldNumber {
   widget: 'number';
   default?: string | number;
@@ -258,7 +273,7 @@ export interface CmsFieldMeta {
   label: string;
   widget: string;
   required: boolean;
-  index_file: string;
+  index_file?: string;
   meta: boolean;
 }
 
@@ -272,6 +287,7 @@ export type CmsField = CmsFieldBase &
     | CmsFieldList
     | CmsFieldMap
     | CmsFieldMarkdown
+    | CmsFieldRichText
     | CmsFieldNumber
     | CmsFieldObject
     | CmsFieldRelation
@@ -290,6 +306,7 @@ export interface CmsCollectionFile {
   description?: string;
   preview_path?: string;
   preview_path_date_field?: string;
+  preview_path_preserve_slashes?: boolean;
   i18n?: boolean | CmsI18nConfig;
   media_folder?: string;
   public_folder?: string;
@@ -327,6 +344,7 @@ export interface CmsCollection {
   slug?: string;
   preview_path?: string;
   preview_path_date_field?: string;
+  preview_path_preserve_slashes?: boolean;
   create?: boolean;
   delete?: boolean;
   editor?: {
@@ -338,7 +356,7 @@ export interface CmsCollection {
     depth: number;
   };
   type: typeof FOLDER | typeof FILES;
-  meta?: { path?: { label: string; widget: string; index_file: string } };
+  meta?: { path?: { label: string; widget: string; index_file?: string } };
 
   /**
    * It accepts the following values: yml, yaml, toml, json, md, markdown, html
@@ -578,6 +596,7 @@ export type EntryField = StaticallyTypedRecord<{
   name: string;
   default: string | null | boolean | List<unknown>;
   media_folder?: string;
+  multiple?: boolean;
   public_folder?: string;
   comment?: string;
   meta?: boolean;
@@ -634,6 +653,7 @@ type CollectionObject = {
   public_folder?: string;
   preview_path?: string;
   preview_path_date_field?: string;
+  preview_path_preserve_slashes?: boolean;
   summary?: string;
   filter?: FilterRule;
   type: 'file_based_collection' | 'folder_based_collection';