decap-cms-backend-github 3.4.0 → 3.6.0

package/dist/esm/API.js

@@ -91,14 +91,18 @@ export default class API {
         token: this.token
       });
     }
-    return this._userPromise;
+    return this._userPromise.then(user => ({
+      name: user.name || 'Unknown',
+      login: user.login,
+      email: user.email ?? undefined
+    }));
   }
   async hasWriteAccess() {
     try {
       const result = await this.request(this.repoURL);
       // update config repoOwner to avoid case sensitivity issues with GitHub
       this.repoOwner = result.owner.login;
-      return result.permissions.push;
+      return result.permissions?.push ?? false;
     } catch (error) {
       console.error('Problem fetching repo data from GitHub');
       throw error;
@@ -402,7 +406,7 @@ export default class API {
     const [{
       files
     }, pullRequestAuthor] = await Promise.all([this.getDifferences(this.branch, pullRequest.head.sha), this.getPullRequestAuthor(pullRequest)]);
-    const diffs = await Promise.all(files.map(file => this.diffFromFile(file)));
+    const diffs = await Promise.all((files || []).map(file => this.diffFromFile(file)));
     const label = pullRequest.labels.find(l => isCMSLabel(l.name, this.cmsLabelPrefix));
     const status = labelToStatus(label.name, this.cmsLabelPrefix);
     const updatedAt = pullRequest.updated_at;
@@ -450,8 +454,8 @@ export default class API {
           commit
         } = result[0];
         return {
-          author: commit.author.name || commit.author.email,
-          updatedOn: commit.author.date
+          author: commit.author?.name || commit.author?.email || '',
+          updatedOn: commit.author?.date || ''
         };
       } catch (e) {
         return {
@@ -502,12 +506,12 @@ export default class API {
       });
       return result.tree
       // filter only files and up to the required depth
-      .filter(file => file.type === 'blob' && file.path.split('/').length <= depth).map(file => ({
+      .filter(file => file.type === 'blob' && file.path && file.path.split('/').length <= depth).map(file => ({
         type: file.type,
         id: file.sha,
         name: basename(file.path),
         path: `${folder}/${file.path}`,
-        size: file.size
+        size: file.size || 0
       }));
     } catch (err) {
       if (err && err.status === 404) {
@@ -668,7 +672,7 @@ export default class API {
     const resp = await this.request(`${this.originRepoURL}/commits/${sha}/status`);
     return resp.statuses.map(s => ({
       context: s.context,
-      target_url: s.target_url,
+      target_url: s.target_url || '',
       state: s.state === GitHubCommitStatusState.Success ? PreviewState.Success : PreviewState.Other
     }));
   }
@@ -744,7 +748,7 @@ export default class API {
     return {
       path: diff.filename,
       newFile: diff.status === 'added',
-      sha: diff.sha,
+      sha: diff.sha || '',
       // media files diffs don't have a patch attribute, except svg files
       // renamed files don't have a patch attribute too
       binary: diff.status !== 'renamed' && !diff.patch || diff.filename.endsWith('.svg')
@@ -769,7 +773,7 @@ export default class API {
       const {
         files: diffFiles
       } = await this.getDifferences(this.branch, await this.getHeadReference(branch));
-      const diffs = await Promise.all(diffFiles.map(file => this.diffFromFile(file)));
+      const diffs = await Promise.all((diffFiles || []).map(file => this.diffFromFile(file)));
       // mark media files to remove
       const mediaFilesToRemove = [];
       for (const diff of diffs.filter(d => d.binary)) {
@@ -824,7 +828,15 @@ export default class API {
       } = commit.commit;
 
       // create a new commit from the updated tree
-      const newCommit = await this.createCommit(message, tree.sha, [baseCommit.sha], author, committer);
+      const newCommit = await this.createCommit(message, tree.sha, [baseCommit.sha], author ? {
+        name: author.name || '',
+        email: author.email || '',
+        date: author.date
+      } : undefined, committer ? {
+        name: committer.name || '',
+        email: committer.email || '',
+        date: committer.date
+      } : undefined);
       return newCommit;
     } else {
       return commit;

package/dist/esm/implementation.js

@@ -124,11 +124,18 @@ export default class GitHub {
     token
   }) {
     if (!this._currentUserPromise) {
-      this._currentUserPromise = fetch(`${this.apiRoot}/user`, {
-        headers: {
-          Authorization: `${this.tokenKeyword} ${token}`
-        }
-      }).then(res => res.json());
+      this._currentUserPromise = (async () => {
+        const res = await fetch(`${this.apiRoot}/user`, {
+          headers: {
+            Authorization: `${this.tokenKeyword} ${token}`
+          }
+        });
+        const user = await res.json();
+        return {
+          ...user,
+          name: user.name || 'Unknown'
+        };
+      })();
     }
     return this._currentUserPromise;
   }
@@ -255,7 +262,7 @@ export default class GitHub {
       useOpenAuthoring: this.useOpenAuthoring,
       initialWorkflowStatus: this.options.initialWorkflowStatus,
       baseUrl: this.baseUrl,
-      getUser: this.currentUser
+      getUser: args => this.currentUser(args)
     });
     const user = await this.api.user();
     const isCollab = await this.api.hasWriteAccess().catch(error => {

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/dist/esm/rateLimitLink.js

@@ -0,0 +1,24 @@
+/**
+ * Rate limit info type and callback
+ */
+
+/**
+ * Extracts rate limit information from response headers
+ */
+export function extractRateLimitInfo(headers) {
+  const used = headers.get('x-ratelimit-used');
+  const limit = headers.get('x-ratelimit-limit');
+  const remaining = headers.get('x-ratelimit-remaining');
+  const reset = headers.get('x-ratelimit-reset');
+  const resource = headers.get('x-ratelimit-resource');
+  if (!used || !limit || !remaining || !reset || !resource) {
+    return null;
+  }
+  return {
+    used: parseInt(used, 10),
+    limit: parseInt(limit, 10),
+    remaining: parseInt(remaining, 10),
+    reset: parseInt(reset, 10),
+    resource
+  };
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "decap-cms-backend-github",
   "description": "GitHub backend for Decap CMS",
-  "version": "3.4.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": "d3465f53b7f056ad5d872948a07eaa8e4ae63315"
+  "gitHead": "45c9f5b9a1a12f74321ce4658b71ec88d6365ec1"
 }