decap-cms-backend-github 3.8.1 → 3.8.3

package/src/implementation.tsx

@@ -19,11 +19,12 @@ import {
   contentKeyFromBranch,
   unsentRequest,
   branchFromContentKey,
+  NotesPollingManager,
+  markOwnNotes,
 } from 'decap-cms-lib-util';
 
 import AuthenticationPage from './AuthenticationPage';
 import API, { API_NAME } from './API';
-import { ETagPollingManager } from './polling';
 import GraphQLAPI from './GraphQLAPI';
 
 import type { Endpoints } from '@octokit/types';
@@ -92,7 +93,7 @@ export default class GitHub implements Implementation {
     [key: string]: Promise<boolean>;
   };
   _mediaDisplayURLSem?: Semaphore;
-  pollingManager?: ETagPollingManager;
+  pollingManager?: NotesPollingManager;
   unwatchFunctions: Map<string, () => void> = new Map();
 
   constructor(config: Config, options = {}) {
@@ -386,7 +387,7 @@ export default class GitHub implements Implementation {
     // }
 
     if (this.api && !this.pollingManager) {
-      this.pollingManager = new ETagPollingManager(this.api, 15000);
+      this.pollingManager = new NotesPollingManager(this.api, 15000);
     }
     // Authorized user
     return { ...user, token: state.token as string, useOpenAuthoring: this.useOpenAuthoring };
@@ -751,24 +752,55 @@ export default class GitHub implements Implementation {
 
   // Notes implementation, which is an abstraction to Github's PR issue comments.
 
+  /**
+   * Who the signed-in editor is, as a note records them: a display name for the
+   * pane and a stable id for the ownership check behind Edit/Resolve/Delete.
+   */
+  async noteAuthorIdentity(): Promise<{ author: string; authorId?: string }> {
+    const currentUser = await this.currentUser({ token: this.token! });
+    return {
+      author: currentUser.login || currentUser.name || '',
+      // No id on purpose: GitHub reports the author's current login on every
+      // read, so ownership follows a rename. Recording it here would freeze it.
+      authorId: undefined,
+    };
+  }
+
+  /**
+   * Resolves each note's `isOwn` here rather than in the pane, because only the
+   * backend knows how its identities compare. Falls back to the display name
+   * for notes with no recorded id.
+   */
+  private async markOwnNotes(notes: Note[]): Promise<Note[]> {
+    return markOwnNotes(notes, await this.noteAuthorIdentity());
+  }
+
   // Notes implementation using GitHub Issues
   async getNotes(collection: string, slug: string): Promise<Note[]> {
     try {
       const notes = await this.api!.getEntryNotes(collection, slug);
-      return notes.map(note => ({ ...note, entrySlug: slug }));
+      return this.markOwnNotes(notes.map(note => ({ ...note, entrySlug: slug })));
     } catch (error) {
       console.error('Failed to get notes:', error);
       return [];
     }
   }
 
-  async addNote(collection: string, slug: string, noteData: Omit<Note, 'id'>): Promise<Note> {
+  async addNote(
+    collection: string,
+    slug: string,
+    noteData: Omit<Note, 'id'>,
+    entryTitle?: string,
+  ): Promise<Note> {
     const currentUser = await this.currentUser({ token: this.token! });
+    const identity = await this.noteAuthorIdentity();
 
     const note: Note = {
       ...noteData,
       id: 'temp-' + Date.now(),
-      author: currentUser.login || currentUser.name || '',
+      author: identity.author,
+      authorId: identity.authorId,
+      isOwn: true,
       avatarUrl: currentUser.avatar_url,
       entrySlug: slug,
       timestamp: noteData.timestamp || new Date().toISOString(),
@@ -776,16 +808,6 @@ export default class GitHub implements Implementation {
       issueUrl: undefined,
     };
 
-    // Get entry title for better issue naming
-    let entryTitle: string | undefined;
-    try {
-      const entryData = await this.getEntry(`${collection}/${slug}.md`);
-      const titleMatch = entryData.data.match(/^title:\s*["']?([^"'\n]+)["']?/m);
-      entryTitle = titleMatch ? titleMatch[1] : undefined;
-    } catch (error) {
-      // Entry not found or error reading, use undefined title
-    }
-
     const { commentId, issueUrl } = await this.api!.addNoteToEntry(
       collection,
       slug,
@@ -883,7 +905,14 @@ export default class GitHub implements Implementation {
       const unwatchFn = await this.pollingManager.watchIssueWithRetry(
         collection,
         slug,
-        callbacks,
+        {
+          ...callbacks,
+          // The polling manager rebuilds notes straight from the issue's
+          // comments, so they arrive without the ownership flag getNotes adds.
+          // Without this, a poll silently strips Edit/Resolve/Delete off the
+          // editor's own notes ~15s after they appear.
+          prepareNotes: notes => this.markOwnNotes(notes),
+        },
         5, // maxRetries - will try up to 5 times
         2000, // retryDelay - 2 seconds between attempts
       );
@@ -908,9 +937,9 @@ export default class GitHub implements Implementation {
     if (unwatchFn) {
       unwatchFn();
       this.unwatchFunctions.delete(issueKey);
-    } else {
-      console.log(`[DecapNotes Polling] No active polling found for ${issueKey}`);
     }
+
+    this.pollingManager?.stopWatching(collection, slug);
   }
 
   /**

package/dist/esm/polling.js

@@ -1,391 +0,0 @@
-/**
- * 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;