fix(core): return full entry object from invokeEvent instead of just data (#7667)

The `invokeEvent` function in registry.js was returning only the data
payload (`_data.entry.get('data')`) instead of returning the complete
entry object. This caused entry metadata fields (slug, path, meta, etc.)
to be lost during event processing, particularly affecting file
collections that rely on slug for file lookups.

When `invokePreSaveEvent` was called during entry persistence:

1. Entry starts with all metadata: slug, path, meta, isModification, etc.
2. `invokeEvent` is called with the full entry object
3. `invokeEvent` returns ONLY the data payload, stripping metadata
4. Calling code replaces the full entry with just the data payload
5. Downstream operations like `entryToRaw` receive incomplete entry
6. `fieldsOrder` method fails trying to match slug to file definitions

This manifested as errors like:
- "No file found for undefined in [collection]"
- "TypeError: can't access property 'toJS', file is undefined"

The bug was introduced in commit 0d7e36b (January 31, 2020) and has
existed for ~5 years, but was only exposed in recent versions (3.2.0+)
when file collection persistence logic started calling `invokePreSaveEvent`
and fully relying on its return value to update the entry draft.

Changed `invokeEvent` to return `_data.entry` (the complete entry object)
instead of `_data.entry.get('data')` (just the data payload).

This preserves all entry metadata through the event handler chain, ensuring
that callers like `invokePreSaveEvent` receive the complete entry object
with all properties intact.

Verified fix resolves file collection publishing issues where:
- Custom widgets modify entry data during save
- File collections with single files rely on slug matching
- Entry metadata must be preserved through preSave event handlers

Fixes #[issue-number-if-exists]

fix(core): test returning full entry when invoking preSave handler

Co-authored-by: Yan <61414485+yanthomasdev@users.noreply.github.com>
Co-authored-by: Martin Jagodic <jagodicmartin1@gmail.com>

Author: 3 people

packages/decap-cms-core/src/__tests__/backend.spec.js

@@ -391,6 +391,68 @@ describe('Backend', () => {
       expect(backend.entryToRaw).toHaveBeenCalledTimes(1);
       expect(backend.entryToRaw).toHaveBeenCalledWith(collection, newEntry);
     });
+
+    it('should preserve slug when preSave event handler modifies file collection entry', async () => {
+      const implementation = {
+        init: jest.fn(() => implementation),
+        persistEntry: jest.fn(() => implementation),
+      };
+
+      const config = {
+        backend: {
+          commit_messages: 'commit-messages',
+        },
+      };
+
+      // File collection with a single file
+      const collection = Map({
+        name: 'settings',
+        type: FILES,
+        files: List([
+          Map({
+            name: 'config',
+            file: 'data/config.json',
+            fields: List([Map({ name: 'title', widget: 'string' })]),
+          }),
+        ]),
+      });
+
+      const originalEntry = Map({
+        slug: 'config',
+        path: 'data/config.json',
+        data: Map({ title: 'original' }),
+        meta: Map({ path: 'data/config.json' }),
+      });
+
+      const entryDraft = Map({
+        entry: originalEntry,
+      });
+
+      const user = { login: 'login', name: 'name' };
+      const backend = new Backend(implementation, { config, backendName: 'github' });
+
+      backend.currentUser = jest.fn().mockResolvedValue(user);
+      backend.entryToRaw = jest.fn().mockReturnValue('content');
+
+      // Mock invokePreSaveEvent to simulate a preSave handler that modifies data
+      // This is what happens when custom widgets or event handlers modify entry data
+      // The key is that it returns the FULL entry with slug, not just the data
+      backend.invokePreSaveEvent = jest.fn().mockImplementation(async entry => {
+        // Simulate a preSave handler modifying the data field
+        return entry.setIn(['data', 'title'], 'modified');
+      });
+
+      await backend.persistEntry({ config, collection, entryDraft });
+
+      // Verify entryToRaw was called with an entry that has the slug
+      expect(backend.entryToRaw).toHaveBeenCalledTimes(1);
+      const entryPassedToRaw = backend.entryToRaw.mock.calls[0][1];
+
+      // Critical assertion: slug must be preserved
+      expect(entryPassedToRaw.get('slug')).toBe('config');
+      expect(entryPassedToRaw.get('path')).toBe('data/config.json');
+      expect(entryPassedToRaw.getIn(['data', 'title'])).toBe('modified');
+    });
   });
 
   describe('persistMedia', () => {

packages/decap-cms-core/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);
       });
     });
   });

packages/decap-cms-core/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 }) {