decap-cms-core 3.10.1 → 3.12.0

package/src/components/Editor/EditorToolbar.js

@@ -230,6 +230,24 @@ const RefreshPreviewButton = styled.button`
   span {
     margin-right: 6px;
   }
+
+  &:disabled {
+    cursor: default;
+    opacity: 0.6;
+  }
+
+  ${Icon} {
+    ${props => props.$spinning && `animation: spin 1s linear infinite;`}
+  }
+
+  @keyframes spin {
+    from {
+      transform: rotate(0deg);
+    }
+    to {
+      transform: rotate(360deg);
+    }
+  }
 `;
 
 const PreviewLink = RefreshPreviewButton.withComponent('a');
@@ -285,17 +303,32 @@ export class EditorToolbar extends React.Component {
 
     const { isNewEntry, loadDeployPreview } = this.props;
     if (!isNewEntry) {
-      loadDeployPreview({ maxAttempts: 3 });
+      // 24 attempts × 5s interval = ~2 min polling window.
+      // With editorial workflow, saving remounts the component (navigates to
+      // the unpublished entry view), so componentDidMount is the primary
+      // polling trigger — not componentDidUpdate.
+      this._pollController = new AbortController();
+      loadDeployPreview({ maxAttempts: 24, signal: this._pollController.signal });
     }
   }
 
   componentDidUpdate(prevProps) {
     const { isNewEntry, isPersisting, loadDeployPreview } = this.props;
     if (!isNewEntry && prevProps.isPersisting && !isPersisting) {
-      loadDeployPreview({ maxAttempts: 3 });
+      // Abort any in-flight poll before starting a new one.
+      this._pollController?.abort();
+      this._pollController = new AbortController();
+      // Fires on subsequent saves when the component survives (no remount).
+      // In editorial workflow the first save remounts, so this mainly
+      // covers the second-save-and-beyond case.
+      loadDeployPreview({ maxAttempts: 3, signal: this._pollController.signal });
     }
   }
 
+  componentWillUnmount() {
+    this._pollController?.abort();
+  }
+
   renderSimpleControls = () => {
     const { collection, hasChanged, isNewEntry, showDelete, onDelete, t } = this.props;
     const canCreate = collection.get('create');
@@ -331,7 +364,11 @@ export class EditorToolbar extends React.Component {
             <Icon type="new-tab" size="xsmall" />
           </PreviewLink>
         ) : (
-          <RefreshPreviewButton onClick={loadDeployPreview}>
+          <RefreshPreviewButton
+            onClick={loadDeployPreview}
+            disabled={isFetching}
+            $spinning={isFetching}
+          >
             <span>{t('editor.editorToolbar.deployPreviewPendingButtonLabel')}</span>
             <Icon type="refresh" size="xsmall" />
           </RefreshPreviewButton>

package/src/components/Editor/__tests__/EditorToolbar.spec.js

@@ -117,4 +117,50 @@ describe('EditorToolbar', () => {
       expect(asFragment()).toMatchSnapshot();
     });
   });
+
+  describe('deploy preview polling', () => {
+    it('should poll with maxAttempts: 24 and an AbortSignal on mount for existing entries', () => {
+      render(<EditorToolbar {...props} isNewEntry={false} />);
+      expect(props.loadDeployPreview).toHaveBeenCalledTimes(1);
+      const opts = props.loadDeployPreview.mock.calls[0][0];
+      expect(opts.maxAttempts).toBe(24);
+      expect(opts.signal).toBeInstanceOf(AbortSignal);
+    });
+
+    it('should not poll on mount for new entries', () => {
+      render(<EditorToolbar {...props} isNewEntry={true} />);
+      expect(props.loadDeployPreview).not.toHaveBeenCalled();
+    });
+
+    it('should poll with maxAttempts: 3 after a save completes', () => {
+      const { rerender } = render(<EditorToolbar {...props} isPersisting={true} />);
+      props.loadDeployPreview.mockClear();
+      rerender(<EditorToolbar {...props} isPersisting={false} />);
+      expect(props.loadDeployPreview).toHaveBeenCalledTimes(1);
+      const opts = props.loadDeployPreview.mock.calls[0][0];
+      expect(opts.maxAttempts).toBe(3);
+      expect(opts.signal).toBeInstanceOf(AbortSignal);
+    });
+
+    it('should abort polling on unmount', () => {
+      const { unmount } = render(<EditorToolbar {...props} isNewEntry={false} />);
+      const signal = props.loadDeployPreview.mock.calls[0][0].signal;
+      expect(signal.aborted).toBe(false);
+      unmount();
+      expect(signal.aborted).toBe(true);
+    });
+
+    it('should abort previous poll when a new save triggers a new poll', () => {
+      const { rerender } = render(<EditorToolbar {...props} isPersisting={false} />);
+      const firstSignal = props.loadDeployPreview.mock.calls[0][0].signal;
+
+      // Simulate save completing
+      rerender(<EditorToolbar {...props} isPersisting={true} />);
+      rerender(<EditorToolbar {...props} isPersisting={false} />);
+
+      expect(firstSignal.aborted).toBe(true);
+      const secondSignal = props.loadDeployPreview.mock.calls[1][0].signal;
+      expect(secondSignal.aborted).toBe(false);
+    });
+  });
 });

package/src/components/MediaLibrary/MediaLibraryButtons.js

@@ -2,7 +2,6 @@ import React from 'react';
 import PropTypes from 'prop-types';
 import { css } from '@emotion/react';
 import styled from '@emotion/styled';
-import copyToClipboard from 'copy-text-to-clipboard';
 import { isAbsolutePath } from 'decap-cms-lib-util';
 import { buttons, shadows, zIndex } from 'decap-cms-ui-default';
 
@@ -87,10 +86,10 @@ export class CopyToClipBoardButton extends React.Component {
     this.mounted = false;
   }
 
-  handleCopy = () => {
+  handleCopy = async () => {
     clearTimeout(this.timeout);
     const { path, draft, name } = this.props;
-    copyToClipboard(isAbsolutePath(path) || !draft ? path : name);
+    await navigator.clipboard.writeText(isAbsolutePath(path) || !draft ? path : name);
     this.setState({ copied: true });
     this.timeout = setTimeout(() => this.mounted && this.setState({ copied: false }), 1500);
   };

package/src/components/UI/ErrorBoundary.js

@@ -4,11 +4,10 @@ import { translate } from 'react-polyglot';
 import styled from '@emotion/styled';
 import yaml from 'yaml';
 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';
 
-const ISSUE_URL = 'https://github.com/decaporg/decap-cms/issues/new?';
+const ISSUE_URL = 'https://github.com/decaporg/decap-cms/issues/new';
 
 function getIssueTemplate({ version, provider, browser, config }) {
   return `
@@ -52,6 +51,7 @@ function buildIssueTemplate({ config }) {
 }
 
 function buildIssueUrl({ title, config }) {
+  const issueUrl = config?.issue_reports?.url ?? ISSUE_URL;
   try {
     const body = buildIssueTemplate({ config });
 
@@ -60,10 +60,10 @@ function buildIssueUrl({ title, config }) {
     params.append('body', truncate(body, { length: 4000, omission: '\n...' }));
     params.append('labels', 'type: bug');
 
-    return `${ISSUE_URL}${params.toString()}`;
+    return `${issueUrl}?${params.toString()}`;
   } catch (e) {
     console.log(e);
-    return `${ISSUE_URL}template=bug_report.md`;
+    return `${issueUrl}?template=bug_report.md`;
   }
 }
 
@@ -116,7 +116,7 @@ function RecoveredEntry({ entry, t }) {
       <hr />
       <h2>{t('ui.errorBoundary.recoveredEntry.heading')}</h2>
       <strong>{t('ui.errorBoundary.recoveredEntry.warning')}</strong>
-      <CopyButton onClick={() => copyToClipboard(entry)}>
+      <CopyButton onClick={() => navigator.clipboard.writeText(entry)}>
         {t('ui.errorBoundary.recoveredEntry.copyButtonLabel')}
       </CopyButton>
       <pre>

package/src/constants/configSchema.js

@@ -193,6 +193,12 @@ function getConfigSchema() {
           clean_accents: { type: 'boolean' },
         },
       },
+      issue_reports: {
+        type: 'object',
+        properties: {
+          url: { type: 'string', examples: ['https://example.com/report-issue'] },
+        },
+      },
       collections: {
         type: 'array',
         minItems: 1,

package/src/formats/__tests__/frontmatter.spec.js

@@ -72,6 +72,27 @@ describe('Frontmatter', () => {
       });
     });
 
+    it('should throw on duplicate frontmatter keys', () => {
+      expect(() =>
+        FrontmatterInfer.fromFile('---\ntitle: Hello\ntitle: World\n---\nContent'),
+      ).toThrow(/Map keys must be unique/);
+    });
+
+    it('should throw on duplicate frontmatter keys with explicit YAML format', () => {
+      expect(() =>
+        frontmatterYAML().fromFile('---\ntitle: Hello\ntitle: World\n---\nContent'),
+      ).toThrow(/Map keys must be unique/);
+    });
+
+    it('should not throw when body contains YAML-like patterns', () => {
+      expect(
+        FrontmatterInfer.fromFile('---\ntitle: Hello\n---\ntitle: this is not a duplicate'),
+      ).toEqual({
+        title: 'Hello',
+        body: 'title: this is not a duplicate',
+      });
+    });
+
     it('should stringify YAML with --- delimiters', () => {
       expect(
         FrontmatterInfer.toFile({

package/src/formats/__tests__/yaml.spec.js

@@ -85,6 +85,33 @@ describe('yaml', () => {
         time: '10:05',
       });
     });
+
+    test('throws on duplicate keys', () => {
+      expect(() => yaml.fromFile('title: Hello\ntitle: World')).toThrow(
+        /Map keys must be unique; "title" is repeated/,
+      );
+    });
+
+    test('throws on duplicate nested keys', () => {
+      expect(() => yaml.fromFile('nested:\n  a: 1\n  a: 2')).toThrow(
+        /Map keys must be unique; "a" is repeated/,
+      );
+    });
+
+    test('does not throw when same key appears in different nested objects', () => {
+      expect(yaml.fromFile('obj1:\n  name: foo\nobj2:\n  name: bar')).toEqual({
+        obj1: { name: 'foo' },
+        obj2: { name: 'bar' },
+      });
+    });
+
+    test('logs warnings to console.warn', () => {
+      const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+      // Valid YAML should produce no warnings
+      yaml.fromFile('title: Hello');
+      expect(warnSpy).not.toHaveBeenCalled();
+      warnSpy.mockRestore();
+    });
   });
   describe('toFile', () => {
     test('outputs valid yaml', () => {

package/src/formats/yaml.ts

@@ -41,7 +41,22 @@ export default {
     if (content && content.trim().endsWith('---')) {
       content = content.trim().slice(0, -3);
     }
-    return yaml.parse(content, { customTags: [timestampTag] });
+
+    const doc = yaml.parseDocument(content, {
+      customTags: [timestampTag],
+      prettyErrors: true,
+    });
+
+    for (const warn of doc.warnings) {
+      console.warn(`YAML warning: ${warn.message}`);
+    }
+
+    if (doc.errors.length > 0) {
+      const messages = doc.errors.map(e => e.message).join('\n');
+      throw new Error(`YAML parsing error:\n${messages}`);
+    }
+
+    return doc.toJSON();
   },
 
   toFile(data: object, sortedKeys: string[] = [], comments: Record<string, string> = {}) {

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

@@ -247,6 +247,27 @@ describe('formatters', () => {
         'Ignoring unknown variable “author-email” in open authoring message template.',
       );
     });
+
+    it('should return commit with trailer when signoff_commits is enabled', () => {
+      const collection = Map({ label_singular: 'Collection' });
+      const config = {
+        backend: {
+          signoff_commits: true,
+        },
+      };
+
+      expect(
+        commitMessageFormatter('create', config, {
+          slug: 'doc-slug',
+          path: 'file-path',
+          collection,
+          authorName: 'Test User',
+          authorEmail: 'test-user@example.org',
+        }),
+      ).toEqual(
+        'Create Collection “doc-slug”\n\nSigned-off-by: Test User <test-user@example.org>\n',
+      );
+    });
   });
 
   describe('prepareSlug', () => {

package/src/lib/formatters.ts

@@ -44,16 +44,28 @@ type Options = {
   collection?: Collection;
   authorLogin?: string;
   authorName?: string;
+  authorEmail?: string;
 };
 
 export function commitMessageFormatter(
   type: keyof typeof commitMessageTemplates,
   config: CmsConfig,
-  { slug, path, collection, authorLogin, authorName }: Options,
+  { slug, path, collection, authorLogin, authorName, authorEmail }: Options,
   isOpenAuthoring?: boolean,
 ) {
   const templates = { ...commitMessageTemplates, ...(config.backend.commit_messages || {}) };
 
+  let trailers = '';
+  if (config.backend.signoff_commits) {
+    if (!authorName) {
+      console.warn('Option signoff_commits is enabled, but author name is unknown');
+    } else if (!authorEmail) {
+      console.warn('Option signoff_commits is enabled, but author email is unknown');
+    } else {
+      trailers = `\n\nSigned-off-by: ${authorName} <${authorEmail}>\n`;
+    }
+  }
+
   const commitMessage = templates[type].replace(variableRegex, (_, variable) => {
     switch (variable) {
       case 'slug':
@@ -73,7 +85,7 @@ export function commitMessageFormatter(
   });
 
   if (!isOpenAuthoring) {
-    return commitMessage;
+    return commitMessage + trailers;
   }
 
   const message = templates.openAuthoring.replace(variableRegex, (_, variable) => {
@@ -90,7 +102,7 @@ export function commitMessageFormatter(
     }
   });
 
-  return message;
+  return message + trailers;
 }
 
 export function prepareSlug(slug: string) {

package/src/lib/i18n.ts

@@ -308,18 +308,26 @@ export async function getI18nEntry(
   if (structure === I18N_STRUCTURE.SINGLE_FILE) {
     entryValue = mergeSingleFileValue(await getEntryValue(path), defaultLocale, locales);
   } else {
-    const entryValues = await Promise.all(
+    const entryValuesResults = await Promise.allSettled(
       locales.map(async locale => {
         const entryPath = getFilePath(structure, extension, path, slug, locale);
-        const value = await getEntryValue(entryPath).catch(() => null);
+        const value = await getEntryValue(entryPath);
         return { value, locale };
       }),
     );
 
-    const nonNullValues = entryValues.filter(e => e.value !== null) as {
-      value: EntryValue;
-      locale: string;
-    }[];
+    const nonNullValues = entryValuesResults
+      .map(e => (e.status === 'fulfilled' ? e.value : undefined))
+      .filter((e): e is { value: EntryValue; locale: string } => e !== undefined);
+
+    if (nonNullValues.length === 0) {
+      // mergeValues will throw on an empty list, and show the error messages.
+      const [error = new Error('No entry values found for any locale')] = entryValuesResults
+        .map(e => (e.status === 'rejected' ? e.reason : undefined))
+        .filter(e => e !== undefined);
+
+      throw error;
+    }
 
     entryValue = mergeValues(collection, structure, defaultLocale, nonNullValues);
   }

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

@@ -0,0 +1,111 @@
+import deploys, { selectDeployPreview } from '../deploys';
+import {
+  DEPLOY_PREVIEW_REQUEST,
+  DEPLOY_PREVIEW_SUCCESS,
+  DEPLOY_PREVIEW_FAILURE,
+} from '../../actions/deploys';
+
+describe('deploys reducer', () => {
+  it('should return the default state', () => {
+    const result = deploys(undefined, { type: 'UNKNOWN' });
+    expect(result).toEqual({});
+  });
+
+  describe('DEPLOY_PREVIEW_REQUEST', () => {
+    it('should set isFetching to true and status to PENDING', () => {
+      const result = deploys(undefined, {
+        type: DEPLOY_PREVIEW_REQUEST,
+        payload: { collection: 'posts', slug: 'my-post' },
+      });
+      expect(result['posts.my-post']).toEqual({ isFetching: true, status: 'PENDING' });
+    });
+
+    it('should clear stale url and replace status with PENDING', () => {
+      const staleState = {
+        'posts.my-post': {
+          isFetching: false,
+          url: 'https://production.example.com/posts/my-post',
+          status: 'SUCCESS',
+        },
+      };
+      const result = deploys(staleState, {
+        type: DEPLOY_PREVIEW_REQUEST,
+        payload: { collection: 'posts', slug: 'my-post' },
+      });
+      expect(result['posts.my-post']).toEqual({ isFetching: true, status: 'PENDING' });
+      expect(result['posts.my-post'].url).toBeUndefined();
+    });
+  });
+
+  describe('DEPLOY_PREVIEW_SUCCESS', () => {
+    it('should store the deploy preview url and status', () => {
+      const initialState = {
+        'posts.my-post': { isFetching: true },
+      };
+      const result = deploys(initialState, {
+        type: DEPLOY_PREVIEW_SUCCESS,
+        payload: {
+          collection: 'posts',
+          slug: 'my-post',
+          url: 'https://preview.example.com/posts/my-post',
+          status: 'SUCCESS',
+        },
+      });
+      expect(result['posts.my-post']).toEqual({
+        isFetching: false,
+        url: 'https://preview.example.com/posts/my-post',
+        status: 'SUCCESS',
+      });
+    });
+  });
+
+  describe('DEPLOY_PREVIEW_FAILURE', () => {
+    it('should set isFetching to false and status to PENDING', () => {
+      const initialState = {
+        'posts.my-post': { isFetching: true, status: 'PENDING' },
+      };
+      const result = deploys(initialState, {
+        type: DEPLOY_PREVIEW_FAILURE,
+        payload: { collection: 'posts', slug: 'my-post' },
+      });
+      expect(result['posts.my-post'].isFetching).toBe(false);
+      expect(result['posts.my-post'].status).toBe('PENDING');
+    });
+
+    it('should clear url and replace status with PENDING to prevent stale data', () => {
+      const initialState = {
+        'posts.my-post': {
+          isFetching: true,
+          url: 'https://production.example.com/posts/my-post',
+          status: 'SUCCESS',
+        },
+      };
+      const result = deploys(initialState, {
+        type: DEPLOY_PREVIEW_FAILURE,
+        payload: { collection: 'posts', slug: 'my-post' },
+      });
+      expect(result['posts.my-post']).toEqual({
+        isFetching: false,
+        url: undefined,
+        status: 'PENDING',
+      });
+    });
+  });
+
+  describe('selectDeployPreview', () => {
+    it('should return the deploy preview for a given collection and slug', () => {
+      const state = {
+        'posts.my-post': {
+          isFetching: false,
+          url: 'https://preview.example.com/posts/my-post',
+          status: 'SUCCESS',
+        },
+      };
+      expect(selectDeployPreview(state, 'posts', 'my-post')).toBe(state['posts.my-post']);
+    });
+
+    it('should return undefined for unknown collection/slug', () => {
+      expect(selectDeployPreview({}, 'posts', 'unknown')).toBeUndefined();
+    });
+  });
+});

package/src/reducers/deploys.ts

@@ -23,8 +23,7 @@ const deploys = produce((state: Deploys, action: DeploysAction) => {
     case DEPLOY_PREVIEW_REQUEST: {
       const { collection, slug } = action.payload;
       const key = `${collection}.${slug}`;
-      state[key] = state[key] || {};
-      state[key].isFetching = true;
+      state[key] = { isFetching: true, status: 'PENDING' };
       break;
     }
 
@@ -39,7 +38,10 @@ const deploys = produce((state: Deploys, action: DeploysAction) => {
 
     case DEPLOY_PREVIEW_FAILURE: {
       const { collection, slug } = action.payload;
-      state[`${collection}.${slug}`].isFetching = false;
+      const key = `${collection}.${slug}`;
+      state[key].isFetching = false;
+      state[key].url = undefined;
+      state[key].status = 'PENDING';
       break;
     }
   }

package/src/types/redux.ts

@@ -377,6 +377,7 @@ export interface CmsBackend {
   auth_endpoint?: string;
   cms_label_prefix?: string;
   squash_merges?: boolean;
+  signoff_commits?: boolean;
   proxy_url?: string;
   commit_messages?: {
     create?: string;
@@ -399,6 +400,10 @@ export interface CmsLocalBackend {
   allowed_hosts?: string[];
 }
 
+export interface CmsIssueReports {
+  url?: string;
+}
+
 export interface CmsConfig {
   backend: CmsBackend;
   collections: CmsCollection[];
@@ -427,6 +432,7 @@ export interface CmsConfig {
   }[];
   slug?: CmsSlug;
   i18n?: CmsI18nConfig;
+  issue_reports?: CmsIssueReports;
   local_backend?: boolean | CmsLocalBackend;
   editor?: {
     preview?: boolean;