decap-cms-backend-github 3.6.0 → 3.8.0

package/dist/esm/implementation.js

@@ -1,13 +1,12 @@
-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); }
-import * as React from 'react';
 import semaphore from 'semaphore';
 import trimStart from 'lodash/trimStart';
 import { stripIndent } from 'common-tags';
 import { CURSOR_COMPATIBILITY_SYMBOL, Cursor, asyncLock, basename, getBlobSHA, entriesByFolder, entriesByFiles, unpublishedEntries, getMediaDisplayURL, getMediaAsBlob, filterByExtension, getPreviewStatus, runWithLock, blobToFileObj, contentKeyFromBranch, unsentRequest, branchFromContentKey } from 'decap-cms-lib-util';
 import AuthenticationPage from './AuthenticationPage';
 import API, { API_NAME } from './API';
+import { ETagPollingManager } from './polling';
 import GraphQLAPI from './GraphQLAPI';
-import { jsx as ___EmotionJSX } from "@emotion/react";
+import { jsx as _jsx } from "@emotion/react/jsx-runtime";
 const MAX_CONCURRENT_DOWNLOADS = 10;
 const {
   fetchWithTimeout: fetch
@@ -17,6 +16,7 @@ const GITHUB_STATUS_ENDPOINT = `${STATUS_PAGE}/api/v2/components.json`;
 const GITHUB_OPERATIONAL_UNITS = ['API Requests', 'Issues, Pull Requests, Projects'];
 export default class GitHub {
   bypassWriteAccessCheckForAppTokens = false;
+  unwatchFunctions = new Map();
   constructor(config, options = {}) {
     this.options = {
       proxied: false,
@@ -82,9 +82,10 @@ export default class GitHub {
     };
   }
   authComponent() {
-    const wrappedAuthenticationPage = props => ___EmotionJSX(AuthenticationPage, _extends({}, props, {
+    const wrappedAuthenticationPage = props => _jsx(AuthenticationPage, {
+      ...props,
       backend: this
-    }));
+    });
     wrappedAuthenticationPage.displayName = 'AuthenticationPage';
     return wrappedAuthenticationPage;
   }
@@ -290,6 +291,9 @@ export default class GitHub {
     //   }
     // }
 
+    if (this.api && !this.pollingManager) {
+      this.pollingManager = new ETagPollingManager(this.api, 15000);
+    }
     // Authorized user
     return {
       ...user,
@@ -299,6 +303,12 @@ export default class GitHub {
   }
   logout() {
     this.token = null;
+    // Clean up polling
+    if (this.pollingManager) {
+      this.pollingManager.destroy();
+      this.pollingManager = undefined;
+    }
+    this.unwatchFunctions.clear();
     if (this.api && this.api.reset && typeof this.api.reset === 'function') {
       return this.api.reset();
     }
@@ -594,10 +604,169 @@ export default class GitHub {
   }
   deleteUnpublishedEntry(collection, slug) {
     // deleteUnpublishedEntry is a transactional operation
-    return runWithLock(this.lock, () => this.api.deleteUnpublishedEntry(collection, slug), 'Failed to acquire delete entry lock');
+    return runWithLock(this.lock, async () => {
+      await this.api.deleteUnpublishedEntry(collection, slug);
+      // Clean up associated notes issue
+      try {
+        await this.api.closeEntryNotesIssue(collection, slug);
+      } catch (error) {
+        console.warn('Failed to close notes issue during entry deletion:', error);
+      }
+    }, 'Failed to acquire delete entry lock');
   }
   publishUnpublishedEntry(collection, slug) {
     // publishUnpublishedEntry is a transactional operation
-    return runWithLock(this.lock, () => this.api.publishUnpublishedEntry(collection, slug), 'Failed to acquire publish entry lock');
+    return runWithLock(this.lock, async () => {
+      await this.api.publishUnpublishedEntry(collection, slug);
+      await this.api.closeIssueOnPublish(collection, slug);
+    }, 'Failed to acquire publish entry lock');
+  }
+
+  // Notes implementation, which is an abstraction to Github's PR issue comments.
+
+  // Notes implementation using GitHub Issues
+  async getNotes(collection, slug) {
+    try {
+      const notes = await this.api.getEntryNotes(collection, slug);
+      return notes.map(note => ({
+        ...note,
+        entrySlug: slug
+      }));
+    } catch (error) {
+      console.error('Failed to get notes:', error);
+      return [];
+    }
+  }
+  async addNote(collection, slug, noteData) {
+    const currentUser = await this.currentUser({
+      token: this.token
+    });
+    const note = {
+      ...noteData,
+      id: 'temp-' + Date.now(),
+      author: currentUser.login || currentUser.name || '',
+      avatarUrl: currentUser.avatar_url,
+      entrySlug: slug,
+      timestamp: noteData.timestamp || new Date().toISOString(),
+      resolved: noteData.resolved || false,
+      issueUrl: undefined
+    };
+
+    // Get entry title for better issue naming
+    let entryTitle;
+    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, note, entryTitle);
+    return {
+      ...note,
+      id: commentId,
+      issueUrl
+    };
+  }
+  async updateNote(collection, slug, noteId, updates) {
+    const currentNotes = await this.getNotes(collection, slug);
+    const existingNote = currentNotes.find(note => note.id === noteId);
+    if (!existingNote) {
+      throw new Error(`Note with ID ${noteId} not found`);
+    }
+    const updatedNote = {
+      ...existingNote,
+      ...updates,
+      id: noteId,
+      entrySlug: slug
+    };
+    await this.api.updateEntryNote(noteId, updatedNote);
+    return updatedNote;
+  }
+  async deleteNote(collection, slug, noteId) {
+    const currentNotes = await this.getNotes(collection, slug);
+    const noteExists = currentNotes.some(note => note.id === noteId);
+    if (!noteExists) {
+      throw new Error(`Note with ID ${noteId} not found`);
+    }
+    await this.api.deleteEntryNote(noteId);
+  }
+  async toggleNoteResolution(collection, slug, noteId) {
+    const currentNotes = await this.getNotes(collection, slug);
+    const note = currentNotes.find(n => n.id === noteId);
+    if (!note) {
+      throw new Error(`Note with ID ${noteId} not found`);
+    }
+    return this.updateNote(collection, slug, noteId, {
+      resolved: !note.resolved
+    });
+  }
+  async reopenIssueForUnpublishedEntry(collection, slug) {
+    await this.api.reopenIssueOnUnpublish(collection, slug);
+  }
+  /**
+   * Start watching notes for changes
+   * Called from Redux action
+   */
+  async startNotesPolling(collection, slug, callbacks) {
+    if (!this.pollingManager) {
+      console.warn('[DecapNotes Polling] Polling manager not initialized');
+      return;
+    }
+    const issueKey = `${collection}/${slug}`;
+
+    // Check if already watching this exact entry - if so, skip
+    if (this.pollingManager.getStatus().currentWatch === issueKey) {
+      return;
+    }
+
+    // First, ensure any previous polling for this entry is completely stopped
+    const existingUnwatch = this.unwatchFunctions.get(issueKey);
+    if (existingUnwatch) {
+      existingUnwatch();
+      this.unwatchFunctions.delete(issueKey);
+    }
+    try {
+      const unwatchFn = await this.pollingManager.watchIssueWithRetry(collection, slug, callbacks, 5,
+      // maxRetries - will try up to 5 times
+      2000 // retryDelay - 2 seconds between attempts
+      );
+
+      // Store the new unwatch function
+      this.unwatchFunctions.set(issueKey, unwatchFn);
+    } catch (error) {
+      console.error('[DecapNotes Polling] Failed to start polling after retries:', error);
+    }
+  }
+
+  /**
+   * Stop watching notes for changes
+   * Called from Redux action: dispatch(stopNotesPolling(collection, slug))
+   *
+   * Ensures complete cleanup of polling for this entry
+   */
+  async stopNotesPolling(collection, slug) {
+    const issueKey = `${collection}/${slug}`;
+    const unwatchFn = this.unwatchFunctions.get(issueKey);
+    if (unwatchFn) {
+      unwatchFn();
+      this.unwatchFunctions.delete(issueKey);
+    } else {
+      console.log(`[DecapNotes Polling] No active polling found for ${issueKey}`);
+    }
+  }
+
+  /**
+   * Manually refresh notes (force check now)
+   * Called from Redux action: dispatch(refreshNotesNow(collection, slug))
+   */
+  async refreshNotesNow(collection, slug) {
+    if (!this.pollingManager) {
+      throw new Error('Polling manager not initialized');
+    }
+    await this.pollingManager.checkIssueNow(collection, slug);
   }
 }

package/package.json

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