decap-cms-backend-github 3.6.0 → 3.8.0

package/dist/esm/API.js

@@ -7,9 +7,12 @@ import result from 'lodash/result';
 import trimStart from 'lodash/trimStart';
 import trim from 'lodash/trim';
 import { oneLine } from 'common-tags';
-import { getAllResponses, APIError, EditorialWorkflowError, localForage, basename, readFileMetadata, CMS_BRANCH_PREFIX, generateContentKey, DEFAULT_PR_BODY, MERGE_COMMIT_MESSAGE, PreviewState, parseContentKey, branchFromContentKey, isCMSLabel, labelToStatus, statusToLabel, contentKeyFromBranch, requestWithBackoff, unsentRequest, throwOnConflictingBranches } from 'decap-cms-lib-util';
 import { dirname } from 'path';
+import { getAllResponses, APIError, EditorialWorkflowError, localForage, basename, readFileMetadata, CMS_BRANCH_PREFIX, generateContentKey, DEFAULT_PR_BODY, MERGE_COMMIT_MESSAGE, PreviewState, parseContentKey, branchFromContentKey, isCMSLabel, labelToStatus, statusToLabel, contentKeyFromBranch, requestWithBackoff, unsentRequest, throwOnConflictingBranches } from 'decap-cms-lib-util';
 export const API_NAME = 'GitHub';
+const {
+  fetchWithTimeout: fetch
+} = unsentRequest;
 export const MOCK_PULL_REQUEST = -1;
 var GitHubCommitStatusState = /*#__PURE__*/function (GitHubCommitStatusState) {
   GitHubCommitStatusState["Error"] = "error";
@@ -758,9 +761,10 @@ export default class API {
     const contentKey = this.generateContentKey(options.collectionName, slug);
     const branch = branchFromContentKey(contentKey);
     const unpublished = options.unpublished || false;
+    const hasSubfolders = options.hasSubfolders !== false; // default to true
     if (!unpublished) {
       const branchData = await this.getDefaultBranch();
-      const changeTree = await this.updateTree(branchData.commit.sha, files);
+      const changeTree = await this.updateTree(branchData.commit.sha, files, this.branch, hasSubfolders);
       const commitResponse = await this.commit(options.commitMessage, changeTree);
       if (this.useOpenAuthoring) {
         await this.createBranch(branch, commitResponse.sha);
@@ -788,7 +792,7 @@ export default class API {
       // rebase the branch before applying new changes
       const rebasedHead = await this.rebaseBranch(branch);
       const treeFiles = mediaFilesToRemove.concat(files);
-      const changeTree = await this.updateTree(rebasedHead.sha, treeFiles, branch);
+      const changeTree = await this.updateTree(rebasedHead.sha, treeFiles, branch, hasSubfolders);
       const commit = await this.commit(options.commitMessage, changeTree);
       return this.patchBranch(branch, commit.sha, {
         force: true
@@ -933,6 +937,7 @@ export default class API {
     const pullRequest = await this.getBranchPullRequest(branch);
     await this.mergePR(pullRequest);
     await this.deleteBranch(branch);
+    await this.closeIssueOnPublish(collectionName, slug);
   }
   async createRef(type, name, sha) {
     const result = await this.request(`${this.repoURL}/git/refs`, {
@@ -1104,7 +1109,7 @@ export default class API {
     item.sha = response.sha;
     return item;
   }
-  async updateTree(baseSha, files, branch = this.branch) {
+  async updateTree(baseSha, files, branch = this.branch, hasSubfolders = true) {
     const toMove = [];
     const tree = files.reduce((acc, file) => {
       const entry = {
@@ -1129,27 +1134,47 @@ export default class API {
       to,
       sha
     } of toMove) {
-      const sourceDir = dirname(from);
-      const destDir = dirname(to);
-      const files = await this.listFiles(sourceDir, {
-        branch,
-        depth: 100
-      });
-      for (const file of files) {
-        // delete current path
+      if (!hasSubfolders) {
+        // New behavior (subfolders: false): Only move the specific file
+        // Delete the file at the old path
         tree.push({
-          path: file.path,
+          path: trimStart(from, '/'),
           mode: '100644',
           type: 'blob',
           sha: null
         });
-        // create in new path
+        // Create the file at the new path
         tree.push({
-          path: file.path.replace(sourceDir, destDir),
+          path: trimStart(to, '/'),
           mode: '100644',
           type: 'blob',
-          sha: file.path === from ? sha : file.id
+          sha
         });
+      } else {
+        // Legacy behavior (subfolders: true, default): Move all files in the directory
+        // This is for collections where all files in a folder represent a single entry
+        const sourceDir = dirname(from);
+        const destDir = dirname(to);
+        const files = await this.listFiles(sourceDir, {
+          branch,
+          depth: 100
+        });
+        for (const file of files) {
+          // delete current path
+          tree.push({
+            path: file.path,
+            mode: '100644',
+            type: 'blob',
+            sha: null
+          });
+          // create in new path
+          tree.push({
+            path: file.path.replace(sourceDir, destDir),
+            mode: '100644',
+            type: 'blob',
+            sha: file.path === from ? sha : file.id
+          });
+        }
       }
     }
     const newTree = await this.createTree(baseSha, tree);
@@ -1191,4 +1216,414 @@ export default class API {
     const pullRequest = await this.getBranchPullRequest(branch);
     return pullRequest.head.sha;
   }
+
+  /**
+   * Constants for note formatting to aid with PR comment to note conversion
+   */
+  static NOTE_STATUS_RESOLVED = 'RESOLVED';
+  static NOTE_STATUS_OPEN = 'OPEN';
+  static NOTES_LABEL = 'decap-cms-notes';
+  static NOTE_ISSUE_PREFIX = 'Notes: ';
+  // In Github we hide Decap Notes metadata in a HTML comment, that way we can track status of whether or not a note has been resolved (similar to GDocs)
+  static NOTE_REGEX = /^<!-- DecapCMS Note - Status: (RESOLVED|OPEN) -->([\s\S]+)$/;
+
+  /**
+   * Format a note for PR comment display
+   */
+  formatNoteForGithub(note) {
+    const status = note.resolved ? API.NOTE_STATUS_RESOLVED : API.NOTE_STATUS_OPEN;
+    return `<!-- DecapCMS Note - Status: ${status} -->
+${note.content}`;
+  }
+
+  /**
+   * Parse a GitHub comment into a Note object
+   */
+  parseCommentToNote(comment) {
+    if (!comment || !comment.body || !comment.user) {
+      throw new Error('Invalid comment structure');
+    }
+    const structuredMatch = comment.body.match(API.NOTE_REGEX);
+    const content = structuredMatch ? structuredMatch[2].trim() : comment.body;
+    const resolved = structuredMatch ? structuredMatch[1] === API.NOTE_STATUS_RESOLVED : false;
+    if (!content.trim()) {
+      throw new Error('Empty note content');
+    }
+    return {
+      id: comment.id.toString(),
+      author: comment.user.login,
+      avatarUrl: comment.user.avatar_url,
+      timestamp: comment.created_at,
+      content,
+      resolved,
+      entrySlug: ''
+    };
+  }
+
+  /**
+   * Create a GitHub issue for storing notes for a specific entry
+   */
+  async createEntryIssue(collectionName, slug, entryTitle) {
+    const title = `${API.NOTE_ISSUE_PREFIX}${entryTitle || `${collectionName}/${slug}`}`;
+    const body = `This issue tracks notes for entry: \`${collectionName}/${slug}\`\n\n---\n*This issue was created automatically by Decap CMS for note management.*`;
+    const response = await this.request(`${this.repoURL}/issues`, {
+      method: 'POST',
+      body: JSON.stringify({
+        title,
+        body,
+        labels: [API.NOTES_LABEL, `collection:${collectionName}`]
+      })
+    });
+    return response;
+  }
+
+  /**
+   * Find existing issue for an entry (returns null if not found)
+   */
+  async findEntryIssue(collectionName, slug) {
+    // Search for existing issue
+    const searchQuery = `repo:${this.repo} label:${API.NOTES_LABEL} "${collectionName}/${slug}" in:body`;
+    try {
+      const searchResponse = await this.request('/search/issues', {
+        params: {
+          q: searchQuery
+        }
+      });
+      if (searchResponse.items && searchResponse.items.length > 0) {
+        return searchResponse.items[0];
+      }
+      return null;
+    } catch (error) {
+      console.warn('Failed to search for existing notes issue:', error);
+      return null;
+    }
+  }
+  /**
+   * Get issue with ETag support for conditional requests
+   * Returns { status: 304 } if not modified, or { status: 200, data, etag } if modified
+   */
+  async getIssueWithETag(issueNumber, etag) {
+    try {
+      const headers = {
+        Authorization: `${this.tokenKeyword} ${this.token}`
+      };
+      if (etag) {
+        headers['If-None-Match'] = etag;
+      }
+      const response = await fetch(`${this.apiRoot}${this.repoURL}/issues/${issueNumber}`, {
+        headers
+      });
+      if (response.status === 304) {
+        return {
+          status: 304
+        };
+      }
+      if (response.status === 200) {
+        const issue = await response.json();
+        const newETag = response.headers.get('ETag');
+        const commentsResponse = await fetch(`${this.apiRoot}${this.repoURL}/issues/${issueNumber}/comments`, {
+          headers
+        });
+        const commentsRaw = await commentsResponse.json();
+        const comments = commentsRaw.map(comment => ({
+          id: comment.id,
+          body: comment.body,
+          user: comment.user,
+          created_at: comment.created_at,
+          updated_at: comment.updated_at
+        }));
+        const issueState = {
+          number: issue.number,
+          title: issue.title,
+          body: issue.body,
+          state: issue.state,
+          updated_at: issue.updated_at,
+          comments,
+          labels: issue.labels,
+          html_url: issue.html_url
+        };
+        return {
+          status: 200,
+          data: issueState,
+          etag: newETag
+        };
+      }
+      throw new Error(`Unexpected status: ${response.status}`);
+    } catch (error) {
+      if (error.status === 304) {
+        return {
+          status: 304
+        };
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Get the current state of an issue (without ETag)
+   */
+  async getIssueState(issueNumber) {
+    const response = await this.getIssueWithETag(issueNumber, null);
+    if (response.status === 200 && response.data) {
+      return response.data;
+    }
+    throw new Error('Failed to get issue state');
+  }
+  /**
+   * Get comments from a GitHub issue
+   */
+  async getIssueComments(issueNumber) {
+    try {
+      const response = await this.request(`${this.repoURL}/issues/${issueNumber}/comments`);
+      return Array.isArray(response) ? response : [];
+    } catch (error) {
+      console.error('Failed to get issue comments:', error);
+      return [];
+    }
+  }
+
+  /**
+   * Create a comment on a GitHub issue
+   */
+  async createIssueComment(issueNumber, note) {
+    try {
+      const response = await this.request(`${this.repoURL}/issues/${issueNumber}/comments`, {
+        method: 'POST',
+        body: JSON.stringify({
+          body: this.formatNoteForGithub(note)
+        })
+      });
+      return response.id.toString();
+    } catch (error) {
+      console.error('Failed to create issue comment:', error);
+      throw new APIError('Failed to create note', error.status || 500, API_NAME);
+    }
+  }
+
+  /**
+   * Update a GitHub issue comment
+   */
+  async updateIssueComment(commentId, note) {
+    try {
+      await this.request(`${this.repoURL}/issues/comments/${commentId}`, {
+        method: 'PATCH',
+        body: JSON.stringify({
+          body: this.formatNoteForGithub(note)
+        })
+      });
+    } catch (error) {
+      console.error('Failed to update issue comment:', error);
+      throw new APIError('Failed to update note', error.status || 500, API_NAME);
+    }
+  }
+
+  /**
+   * Delete a GitHub issue comment
+   */
+  async deleteIssueComment(commentId) {
+    try {
+      await this.request(`${this.repoURL}/issues/comments/${commentId}`, {
+        method: 'DELETE'
+      });
+    } catch (error) {
+      console.error('Failed to delete issue comment:', error);
+      throw new APIError('Failed to delete note', error.status || 500, API_NAME);
+    }
+  }
+
+  /**
+   * Close the notes issue when an entry is published
+   */
+  async closeIssueOnPublish(collectionName, slug) {
+    try {
+      const searchQuery = `repo:${this.repo} label:${API.NOTES_LABEL} "${collectionName}/${slug}" in:body state:open`;
+      const searchResponse = await this.request('/search/issues', {
+        params: {
+          q: searchQuery
+        }
+      });
+      if (searchResponse.items && searchResponse.items.length > 0) {
+        const issue = searchResponse.items[0];
+        await this.request(`${this.repoURL}/issues/${issue.number}`, {
+          method: 'PATCH',
+          body: JSON.stringify({
+            state: 'closed',
+            labels: [...(issue.labels || []).map(l => l.name), 'entry-published']
+          })
+        });
+      }
+    } catch (error) {
+      console.warn('Failed to close notes issue on publish:', error);
+    }
+  }
+
+  /**
+   * Reopen the notes issue when an entry is unpublished
+   */
+  async reopenIssueOnUnpublish(collectionName, slug) {
+    try {
+      const searchQuery = `repo:${this.repo} label:${API.NOTES_LABEL} "${collectionName}/${slug}" in:body`;
+      const searchResponse = await this.request('/search/issues', {
+        params: {
+          q: searchQuery
+        }
+      });
+      if (searchResponse.items && searchResponse.items.length > 0) {
+        const issue = searchResponse.items[0];
+        // Remove 'entry-published' or 'entry-deleted' labels and reopen
+        const updatedLabels = (issue.labels || []).map(l => l.name).filter(name => name !== 'entry-published' && name !== 'entry-deleted');
+        await this.request(`${this.repoURL}/issues/${issue.number}`, {
+          method: 'PATCH',
+          body: JSON.stringify({
+            state: 'open',
+            labels: updatedLabels
+          })
+        });
+      }
+    } catch (error) {
+      console.warn('Failed to reopen notes issue on unpublish:', error);
+    }
+  }
+
+  /**
+   * Get all notes for an entry
+   */
+  async getEntryNotes(collectionName, slug) {
+    try {
+      const issue = await this.findEntryIssue(collectionName, slug);
+      if (!issue) {
+        return []; // No issue means no notes yet
+      }
+      const comments = await this.getIssueComments(issue.number);
+      const issueUrl = issue.html_url; // Get the issue URL once
+
+      // Add issueUrl to each note
+      return comments.map(comment => ({
+        ...this.parseCommentToNote(comment),
+        issueUrl // Add the issue URL to each note (this info is picked up by the UI to direct users to the source of the Notes in Github)
+      }));
+    } catch (error) {
+      console.error('Failed to get entry notes:', error);
+      return [];
+    }
+  }
+
+  /**
+   * Add a note to any entry
+   */
+  async addNoteToEntry(collectionName, slug, note, entryTitle) {
+    try {
+      let issue = await this.findEntryIssue(collectionName, slug);
+      if (!issue) {
+        issue = await this.createEntryIssue(collectionName, slug, entryTitle);
+      }
+      const commentId = await this.createIssueComment(issue.number, note);
+      return {
+        commentId,
+        issueUrl: issue.html_url
+      };
+    } catch (error) {
+      console.error('Failed to add note to entry:', error);
+      throw new APIError('Failed to create note', error.status || 500, API_NAME);
+    }
+  }
+  async updateEntryNote(noteId, note) {
+    try {
+      await this.updateIssueComment(noteId, note);
+    } catch (error) {
+      console.error('Failed to update entry note:', error);
+      throw new APIError('Failed to update note', error.status || 500, API_NAME);
+    }
+  }
+  async deleteEntryNote(noteId) {
+    try {
+      await this.deleteIssueComment(noteId);
+    } catch (error) {
+      console.error('Failed to delete entry note:', error);
+      throw new APIError('Failed to delete note', error.status || 500, API_NAME);
+    }
+  }
+
+  /**
+   * Get all entries that have notes (useful for showing notes indicator in UI)
+   */
+  async getEntriesWithNotes() {
+    try {
+      const searchQuery = `repo:${this.repo} label:${API.NOTES_LABEL} state:open`;
+      const searchResponse = await this.request('/search/issues', {
+        params: {
+          q: searchQuery,
+          per_page: 100
+        }
+      });
+      const entriesWithNotes = [];
+      for (const issue of searchResponse.items || []) {
+        // Extract collection/slug from issue body
+        const match = issue.body.match(/entry: `(.+)\/(.+)`/);
+        if (match) {
+          const [, collection, slug] = match;
+          entriesWithNotes.push({
+            collection,
+            slug,
+            noteCount: issue.comments
+          });
+        }
+      }
+      return entriesWithNotes;
+    } catch (error) {
+      console.error('Failed to get entries with notes:', error);
+      return [];
+    }
+  }
+
+  /**
+   * Close notes issue when entry is deleted
+   */
+  async closeEntryNotesIssue(collectionName, slug) {
+    try {
+      const searchQuery = `repo:${this.repo} label:${API.NOTES_LABEL} "${collectionName}/${slug}" in:body state:open`;
+      const searchResponse = await this.request('/search/issues', {
+        params: {
+          q: searchQuery
+        }
+      });
+      if (searchResponse.items && searchResponse.items.length > 0) {
+        const issue = searchResponse.items[0];
+        await this.request(`${this.repoURL}/issues/${issue.number}`, {
+          method: 'PATCH',
+          body: JSON.stringify({
+            state: 'closed',
+            labels: [...(issue.labels || []).map(l => l.name), 'entry-deleted']
+          })
+        });
+      }
+    } catch (error) {
+      console.warn('Failed to close notes issue:', error);
+    }
+  }
+
+  /**
+   * Get PR metadata from branch name
+   */
+  async getPRMetadataFromBranch(branchName) {
+    try {
+      const response = await this.request(`${this.originRepoURL}/pulls`, {
+        params: {
+          head: await this.getHeadReference(branchName),
+          state: 'open'
+        }
+      });
+      const pr = response[0];
+      if (!pr) return null;
+      return {
+        id: pr.number.toString(),
+        url: pr.html_url,
+        author: pr.user?.login || 'unknown',
+        createdAt: pr.created_at
+      };
+    } catch (error) {
+      console.error('Failed to get PR metadata:', error);
+      return null;
+    }
+  }
 }

package/dist/esm/AuthenticationPage.js

@@ -1,11 +1,10 @@
 import _styled from "@emotion/styled/base";
-function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
 function _EMOTION_STRINGIFIED_CSS_ERROR__() { return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop)."; }
 import React from 'react';
 import PropTypes from 'prop-types';
 import { NetlifyAuthenticator } from 'decap-cms-lib-auth';
 import { AuthenticationPage, Icon } from 'decap-cms-ui-default';
-import { jsx as ___EmotionJSX } from "@emotion/react";
+import { jsx as _jsx, jsxs as _jsxs } from "@emotion/react/jsx-runtime";
 const LoginButtonIcon = /*#__PURE__*/_styled(Icon, {
   target: "e1ko648l2",
   label: "LoginButtonIcon"
@@ -126,9 +125,11 @@ export default class GitHubAuthenticationPage extends React.Component {
       inProgress,
       t
     } = this.props;
-    return inProgress || this.state.findingFork ? t('auth.loggingIn') : ___EmotionJSX(React.Fragment, null, ___EmotionJSX(LoginButtonIcon, {
-      type: "github"
-    }), t('auth.loginWithGitHub'));
+    return inProgress || this.state.findingFork ? t('auth.loggingIn') : _jsxs(React.Fragment, {
+      children: [_jsx(LoginButtonIcon, {
+        type: "github"
+      }), t('auth.loginWithGitHub')]
+    });
   };
   getAuthenticationPageRenderArgs() {
     const {
@@ -144,11 +145,19 @@ export default class GitHubAuthenticationPage extends React.Component {
           LoginButton,
           TextButton,
           showAbortButton
-        }) => ___EmotionJSX(ForkApprovalContainer, null, ___EmotionJSX("p", null, "Open Authoring is enabled: we need to use a fork on your github account. (If a fork already exists, we'll use that.)"), ___EmotionJSX(ForkButtonsContainer, null, ___EmotionJSX(LoginButton, {
-          onClick: approveFork
-        }, "Fork the repo"), showAbortButton && ___EmotionJSX(TextButton, {
-          onClick: refuseFork
-        }, "Don't fork the repo")))
+        }) => _jsxs(ForkApprovalContainer, {
+          children: [_jsx("p", {
+            children: "Open Authoring is enabled: we need to use a fork on your github account. (If a fork already exists, we'll use that.)"
+          }), _jsxs(ForkButtonsContainer, {
+            children: [_jsx(LoginButton, {
+              onClick: approveFork,
+              children: "Fork the repo"
+            }), showAbortButton && _jsx(TextButton, {
+              onClick: refuseFork,
+              children: "Don't fork the repo"
+            })]
+          })]
+        })
       };
     }
     return {
@@ -166,16 +175,16 @@ export default class GitHubAuthenticationPage extends React.Component {
       requestingFork,
       findingFork
     } = this.state;
-    return ___EmotionJSX(AuthenticationPage, _extends({
+    return _jsx(AuthenticationPage, {
       onLogin: this.handleLogin,
       loginDisabled: inProgress || findingFork || requestingFork,
       loginErrorMessage: loginError,
       logoUrl: config.logo_url // Deprecated, replaced by `logo.src`
       ,
       logo: config.logo,
-      siteUrl: config.site_url
-    }, this.getAuthenticationPageRenderArgs(), {
+      siteUrl: config.site_url,
+      ...this.getAuthenticationPageRenderArgs(),
       t: t
-    }));
+    });
   }
 }