decap-cms-backend-github 3.5.0 → 3.6.0

package/dist/esm/API.js

@@ -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() {

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.6.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": "45c9f5b9a1a12f74321ce4658b71ec88d6365ec1"
 }

package/src/API.ts

@@ -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,
     }));
   }
 

package/dist/esm/types/githubPullRequests.js

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