decap-cms-backend-github 3.5.0 → 3.7.0

package/dist/esm/API.js

@@ -7,8 +7,8 @@ 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';
 export const MOCK_PULL_REQUEST = -1;
 var GitHubCommitStatusState = /*#__PURE__*/function (GitHubCommitStatusState) {
@@ -93,7 +93,8 @@ export default class API {
     }
     return this._userPromise.then(user => ({
       name: user.name || 'Unknown',
-      login: user.login
+      login: user.login,
+      email: user.email ?? undefined
     }));
   }
   async hasWriteAccess() {
@@ -757,9 +758,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);
@@ -787,7 +789,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
@@ -1103,7 +1105,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 = {
@@ -1128,27 +1130,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);

package/dist/esm/polling.js

@@ -0,0 +1,391 @@
+/**
+ * GitHub Notes Polling System
+ *
+ * ETag-based polling manager that efficiently checks for changes in GitHub Issues
+ * Used for a real-time feel of notes updates without excessive API calls leveraging conditional requests (304) that don't count on Github rate limits.
+ *
+ * @module polling
+ */
+
+// Redux action types
+export const NOTES_POLLING_START = 'NOTES_POLLING_START';
+export const NOTES_POLLING_STOP = 'NOTES_POLLING_STOP';
+export const NOTES_POLLING_UPDATE = 'NOTES_POLLING_UPDATE';
+export const NOTES_CHANGE_DETECTED = 'NOTES_CHANGE_DETECTED';
+export class ETagPollingManager {
+  currentWatch = null;
+  currentIssueKey = null;
+  pollingInterval = 15000;
+  intervalId = null;
+  isDocumentVisible = true;
+  isPolling = false;
+  pendingRetryTimeout = null;
+  constructor(api, pollingInterval = 15000) {
+    this.api = api;
+    this.pollingInterval = pollingInterval;
+    this.setupVisibilityListener();
+  }
+
+  /**
+   * Setup Page Visibility API listener
+   * Pauses polling when tab is hidden
+   */
+  setupVisibilityListener() {
+    if (typeof document !== 'undefined') {
+      document.addEventListener('visibilitychange', () => {
+        this.isDocumentVisible = !document.hidden;
+        if (this.isDocumentVisible) {
+          this.startPolling();
+          this.checkAllIssuesNow();
+        } else {
+          this.stopPolling();
+        }
+      });
+    }
+  }
+
+  /**
+   * Start watching an issue for changes
+   * This will automatically stop watching any previously watched issue
+   *
+   * @param issueNumber - GitHub issue number
+   * @param collection - Collection name
+   * @param slug - Entry slug
+   * @returns Function to stop watching
+   */
+  async watchIssue(issueNumber, collection, slug, callbacks, initialState = null) {
+    const issueKey = this.getIssueKey(collection, slug);
+
+    // STOP ANY EXISTING WATCH FIRST
+    if (this.currentWatch) {
+      this.stopCurrentWatch();
+    }
+
+    // Get initial state if not provided
+    if (!initialState) {
+      try {
+        initialState = await this.api.getIssueState(issueNumber);
+      } catch (error) {
+        console.error('[DecapNotes Polling] Failed to get initial state:', error);
+      }
+    }
+    this.currentWatch = {
+      issueNumber,
+      collection,
+      slug,
+      etag: null,
+      lastState: initialState,
+      onUpdate: callbacks.onUpdate,
+      onChange: callbacks.onChange,
+      retryCount: 0,
+      maxRetries: 5
+    };
+    this.currentIssueKey = issueKey;
+
+    // Start polling if not already running
+    if (!this.intervalId && this.isDocumentVisible) {
+      this.startPolling();
+    }
+
+    // Do an immediate check
+    this.checkCurrentIssue();
+
+    // Return unwatch function
+    return () => this.stopCurrentWatch();
+  }
+
+  /**
+   * Watch issue with retry logic for newly created issues
+   */
+  async watchIssueWithRetry(collection, slug, callbacks, maxRetries = 5, retryDelay = 2000) {
+    const issueKey = this.getIssueKey(collection, slug);
+
+    // STOP ANY EXISTING WATCH FIRST
+    if (this.currentWatch) {
+      this.stopCurrentWatch();
+    }
+    const attemptWatch = async attempt => {
+      try {
+        const issue = await this.api.findEntryIssue(collection, slug);
+        if (issue) {
+          return await this.watchIssue(issue.number, collection, slug, callbacks);
+        }
+        if (attempt < maxRetries) {
+          return new Promise((resolve, reject) => {
+            this.pendingRetryTimeout = setTimeout(async () => {
+              this.pendingRetryTimeout = null;
+              try {
+                const unwatchFn = await attemptWatch(attempt + 1);
+                resolve(unwatchFn);
+              } catch (error) {
+                reject(error);
+              }
+            }, retryDelay);
+          });
+        }
+        console.log(`[DecapNotes Polling] No issue found for ${issueKey} after ${maxRetries} attempts. This is expected if there are no notes for this entry yet.`);
+        // Return a no-op unwatch function
+        return () => {
+          /* no-op */
+        };
+      } catch (error) {
+        console.error(`[DecapNotes Polling] Error finding issue for ${issueKey}:`, error);
+        if (attempt < maxRetries) {
+          return new Promise((resolve, reject) => {
+            this.pendingRetryTimeout = setTimeout(async () => {
+              this.pendingRetryTimeout = null;
+              try {
+                const unwatchFn = await attemptWatch(attempt + 1);
+                resolve(unwatchFn);
+              } catch (err) {
+                reject(err);
+              }
+            }, retryDelay);
+          });
+        }
+        throw error;
+      }
+    };
+    return attemptWatch(1);
+  }
+
+  /**
+   * Stop watching the current issue - complete cleanup
+   */
+  stopCurrentWatch() {
+    if (!this.currentWatch) {
+      return;
+    }
+
+    // Clear any pending retry timeout
+    if (this.pendingRetryTimeout) {
+      clearTimeout(this.pendingRetryTimeout);
+      this.pendingRetryTimeout = null;
+    }
+
+    // Clear current watch
+    this.currentWatch = null;
+    this.currentIssueKey = null;
+
+    // Stop polling since there's nothing to watch
+    this.stopPolling();
+  }
+
+  /**
+   * Start the polling loop
+   */
+  startPolling() {
+    if (this.intervalId || !this.isDocumentVisible || !this.currentWatch) return;
+    console.log(`[DecapNotes Polling] Starting polling loop (${this.pollingInterval}ms interval) for ${this.currentIssueKey}`);
+    this.intervalId = setInterval(() => {
+      this.pollAllIssues();
+    }, this.pollingInterval);
+  }
+
+  /**
+   * Stop the polling loop
+   */
+  stopPolling() {
+    if (this.intervalId) {
+      console.log('[DecapNotes Polling] Stopping polling loop');
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+  }
+
+  /**
+   * Poll current watched issue
+   */
+  async pollAllIssues() {
+    await this.checkCurrentIssue();
+  }
+
+  /**
+   * Check current issue for changes using ETag
+   */
+  async checkCurrentIssue() {
+    if (!this.currentWatch) {
+      return;
+    }
+    if (this.isPolling) {
+      return;
+    }
+    this.isPolling = true;
+    try {
+      const watch = this.currentWatch;
+      const response = await this.api.getIssueWithETag(watch.issueNumber, watch.etag);
+      if (response.status === 304) {
+        return;
+      }
+      if (response.status === 200) {
+        const newState = response.data;
+        const newETag = response.etag;
+
+        // Update ETag
+        watch.etag = newETag || null;
+
+        // Detect specific changes
+        const changes = this.detectChanges(watch.lastState, newState);
+        if (changes.length > 0) {
+          // Convert comments to notes
+          const newNotes = newState.comments.map(comment => ({
+            ...this.api.parseCommentToNote(comment),
+            issueUrl: newState.html_url
+          }));
+          if (watch.onUpdate) {
+            watch.onUpdate(newNotes, changes);
+          }
+          if (watch.onChange) {
+            changes.forEach(change => {
+              watch.onChange(change);
+            });
+          }
+        }
+
+        // Update stored state
+        watch.lastState = newState;
+      }
+    } catch (error) {
+      if (error && typeof error === 'object' && 'status' in error && error.status !== 304) {
+        console.error(`[DecapNotes Polling] Error checking ${this.currentIssueKey}:`, error);
+      }
+    } finally {
+      this.isPolling = false;
+    }
+  }
+
+  /**
+   * Immediately check current issue
+   */
+  async checkAllIssuesNow() {
+    await this.checkCurrentIssue();
+  }
+
+  /**
+   * Manually trigger a check - only works if this is the current entry
+   */
+  async checkIssueNow(collection, slug) {
+    const issueKey = this.getIssueKey(collection, slug);
+    if (this.currentIssueKey !== issueKey) {
+      console.warn(`[DecapNotes Polling] Cannot check ${issueKey} - currently watching ${this.currentIssueKey}`);
+      return;
+    }
+    await this.checkCurrentIssue();
+  }
+
+  /**
+   * Detect what changed between two states
+   */
+  detectChanges(previous, current) {
+    if (!previous) {
+      return [];
+    }
+    const changes = [];
+
+    // New comments
+    const newComments = current.comments.filter(comment => !previous.comments.some(prev => prev.id === comment.id));
+    newComments.forEach(comment => {
+      changes.push({
+        type: 'comment_added',
+        data: comment,
+        timestamp: comment.created_at
+      });
+    });
+
+    // Updated comments
+    current.comments.forEach(comment => {
+      const prevComment = previous.comments.find(prev => prev.id === comment.id);
+      if (prevComment && prevComment.updated_at !== comment.updated_at) {
+        changes.push({
+          type: 'comment_updated',
+          data: comment,
+          previousData: prevComment,
+          timestamp: comment.updated_at
+        });
+      }
+    });
+
+    // Deleted comments
+    const deletedComments = previous.comments.filter(prevComment => !current.comments.some(comment => comment.id === prevComment.id));
+    deletedComments.forEach(comment => {
+      changes.push({
+        type: 'comment_deleted',
+        data: comment,
+        timestamp: new Date().toISOString()
+      });
+    });
+
+    // Issue state changed
+    if (previous.state !== current.state) {
+      changes.push({
+        type: 'issue_state_changed',
+        data: {
+          from: previous.state,
+          to: current.state
+        },
+        timestamp: current.updated_at
+      });
+    }
+
+    // Labels changed
+    if (this.hasLabelsChanged(previous.labels, current.labels)) {
+      changes.push({
+        type: 'issue_labels_changed',
+        data: {
+          from: previous.labels,
+          to: current.labels
+        },
+        timestamp: current.updated_at
+      });
+    }
+    return changes;
+  }
+
+  /**
+   * Check if labels changed
+   */
+  hasLabelsChanged(previous, current) {
+    if (previous.length !== current.length) return true;
+    const prevNames = previous.map(l => l.name).sort();
+    const currNames = current.map(l => l.name).sort();
+    return prevNames.join(',') !== currNames.join(',');
+  }
+
+  /**
+   * Get issue key for storage
+   */
+  getIssueKey(collection, slug) {
+    return `${collection}/${slug}`;
+  }
+
+  /**
+   * Get polling status
+   */
+  getStatus() {
+    return {
+      isPolling: this.intervalId !== null,
+      currentWatch: this.currentIssueKey,
+      watchedCount: this.currentWatch ? 1 : 0,
+      pollingInterval: this.pollingInterval,
+      isDocumentVisible: this.isDocumentVisible,
+      hasPendingRetry: this.pendingRetryTimeout !== null
+    };
+  }
+
+  /**
+   * Clean up - stop all polling
+   */
+  destroy() {
+    console.log('[DecapNotes Polling] Destroying polling manager');
+
+    // Clear pending retry
+    if (this.pendingRetryTimeout) {
+      clearTimeout(this.pendingRetryTimeout);
+      this.pendingRetryTimeout = null;
+    }
+
+    // Stop current watch
+    this.stopCurrentWatch();
+  }
+}
+export default ETagPollingManager;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "decap-cms-backend-github",
   "description": "GitHub backend for Decap CMS",
-  "version": "3.5.0",
+  "version": "3.7.0",
   "license": "MIT",
   "repository": "https://github.com/decaporg/decap-cms/tree/main/packages/decap-cms-backend-github",
   "bugs": "https://github.com/decaporg/decap-cms/issues",
@@ -44,5 +44,5 @@
   "browser": {
     "path": "path-browserify"
   },
-  "gitHead": "0c1b7c7d63ba6ddb3de3692fbb6b16ac6ebb44d5"
+  "gitHead": "ae01ad6f2b139f93472c8f0d049d35277d8583ca"
 }

package/src/API.ts

@@ -7,6 +7,7 @@ import result from 'lodash/result';
 import trimStart from 'lodash/trimStart';
 import trim from 'lodash/trim';
 import { oneLine } from 'common-tags';
+import { dirname } from 'path';
 import {
   getAllResponses,
   APIError,
@@ -29,7 +30,6 @@ import {
   unsentRequest,
   throwOnConflictingBranches,
 } from 'decap-cms-lib-util';
-import { dirname } from 'path';
 
 import type {
   AssetProxy,
@@ -253,13 +253,14 @@ export default class API {
 
   static DEFAULT_COMMIT_MESSAGE = 'Automatically generated by Decap CMS';
 
-  user(): Promise<{ name: string; login: string }> {
+  user(): Promise<{ name: string; login: string; email?: string }> {
     if (!this._userPromise) {
       this._userPromise = this.getUser({ token: this.token });
     }
     return this._userPromise.then(user => ({
       name: user.name || 'Unknown',
       login: user.login,
+      email: user.email ?? undefined,
     }));
   }
 
@@ -1010,9 +1011,15 @@ export default class API {
     const contentKey = this.generateContentKey(options.collectionName as string, 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) {
@@ -1047,7 +1054,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 });
@@ -1417,6 +1424,7 @@ export default class API {
     baseSha: string,
     files: { path: string; sha: string | null; newPath?: string }[],
     branch = this.branch,
+    hasSubfolders = true,
   ) {
     const toMove: { from: string; to: string; sha: string }[] = [];
     const tree = files.reduce((acc, file) => {
@@ -1437,24 +1445,44 @@ export default class API {
     }, [] as TreeEntry[]);
 
     for (const { from, 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,
+          });
+        }
       }
     }
 

package/dist/esm/types/githubPullRequests.js

@@ -1 +0,0 @@
-export {};