feat(api): merge query

Signed-off-by: Adam Setch <[email protected]>

Author: setchy

src/renderer/utils/api/graphql/utils.ts

@@ -1,22 +1,90 @@
-export function getQueryFragmentBody(doc: string): string | null {
-  // Find fragment on Query pattern
-  const fragmentMatch = doc.match(/fragment\s+\w+\s+on\s+Query\s+\{/);
-  if (!fragmentMatch) {
-    return null;
-  }
+// Shared patterns for fragment parsing
+const FRAGMENT_BLOCK_REGEX =
+  /fragment\s+[A-Za-z0-9_]+\s+on\s+[A-Za-z0-9_]+\s*\{/g;
+const FRAGMENT_NAME_REGEX = /fragment\s+([A-Za-z0-9_]+)\s+on\s+([A-Za-z0-9_]+)/;
 
-  const start = fragmentMatch.index + fragmentMatch[0].length - 1; // Position of opening brace
-  let depth = 0;
+type ParsedFragment = {
+  name: string;
+  onType: string;
+  content: string; // inside the outermost braces
+  full: string; // full fragment text including header and braces
+};
 
-  for (let i = start; i < doc.length; i++) {
-    if (doc[i] === '{') {
+function sliceBraceBlock(doc: string, startIndex: number): string | null {
+  let depth = 0;
+  for (let i = startIndex; i < doc.length; i++) {
+    const ch = doc[i];
+    if (ch === '{') {
       depth++;
-    } else if (doc[i] === '}') {
+    } else if (ch === '}') {
       depth--;
       if (depth === 0) {
-        return doc.slice(start + 1, i).trim();
+        // Include braces
+        return doc.slice(startIndex, i + 1);
       }
     }
   }
   return null;
 }
+
+export function parseFragments(doc: string): ParsedFragment[] {
+  const results: ParsedFragment[] = [];
+  // Find each fragment header position
+  const indices: number[] = [];
+  for (const m of doc.matchAll(FRAGMENT_BLOCK_REGEX)) {
+    if (m.index !== undefined) {
+      indices.push(m.index);
+    }
+  }
+
+  for (const idx of indices) {
+    const header = doc.slice(idx, idx + 200); // small window for name/type parse
+    const nt = header.match(FRAGMENT_NAME_REGEX);
+    if (!nt) {
+      continue;
+    }
+    const name = nt[1];
+    const onType = nt[2];
+    // Find the opening brace for this header
+    const bracePos = doc.indexOf('{', idx);
+    if (bracePos === -1) {
+      continue;
+    }
+    const block = sliceBraceBlock(doc, bracePos);
+    if (!block) {
+      continue;
+    }
+    const full = doc.slice(idx, bracePos) + block;
+    const content = block.slice(1, block.length - 1).trim();
+    results.push({ name, onType, content, full: full.trim() });
+  }
+  return results;
+}
+
+export function getQueryFragmentBody(doc: string): string | null {
+  const frags = parseFragments(doc);
+  const qFrag = frags.find((f) => f.onType === 'Query');
+  return qFrag?.content ?? null;
+}
+
+export function extractFragments(doc: string): Map<string, string> {
+  const frags = parseFragments(doc);
+  const map = new Map<string, string>();
+  for (const f of frags) {
+    if (!map.has(f.name)) {
+      map.set(f.name, f.full);
+    }
+  }
+  return map;
+}
+
+// Helper to compose a merged query given selections, fragments and variable defs
+export function composeMergedQuery(
+  selections: string[],
+  fragmentMap: Map<string, string>,
+  variableDefinitions: string[],
+): string {
+  const vars = variableDefinitions.join(', ');
+  const frags = Array.from(fragmentMap.values()).join('\n');
+  return `query FetchMergedNotifications(${vars}) {\n${selections.join('\n')}\n}\n\n${frags}\n`;
+}

src/renderer/utils/notifications/filters/search.test.ts

@@ -22,7 +22,7 @@ describe('renderer/utils/notifications/filters/search.ts', () => {
 
     it('matches each known qualifier by its exact prefix and additional value', () => {
       for (const q of ALL_SEARCH_QUALIFIERS) {
-        const token = q.prefix + 'someValue';
+        const token = `${q.prefix}someValue`;
         const parsed = parseSearchInput(token);
         expect(parsed).not.toBeNull();
         expect(parsed?.qualifier).toBe(q);

src/renderer/utils/notifications/notifications.ts

@@ -10,6 +10,7 @@ import type {
 import type { Notification } from '../../typesGitHub';
 import { listNotificationsForAuthenticatedUser } from '../api/client';
 import { determineFailureType } from '../api/errors';
+import { composeMergedQuery, extractFragments } from '../api/graphql/utils';
 import { getHeaders } from '../api/request';
 import { getGitHubGraphQLUrl, getNumberFromUrl } from '../api/utils';
 import { rendererLogError, rendererLogWarn } from '../logger';
@@ -147,19 +148,10 @@ export async function enrichNotifications(
   }> = [];
 
   const collectFragments = (doc: string) => {
-    const fragmentRegex =
-      /fragment\s+[A-Za-z0-9_]+\s+on[\s\S]*?(?=(?:fragment\s+[A-Za-z0-9_]+\s+on)|$)/g;
-    const nameRegex = /fragment\s+([A-Za-z0-9_]+)\s+on/;
-
-    const matches = doc.match(fragmentRegex) ?? [];
-    for (const match of matches) {
-      const nameMatch = match.match(nameRegex);
-      if (!nameMatch) {
-        continue;
-      }
-      const name = nameMatch[1];
+    const found = extractFragments(doc);
+    for (const [name, frag] of found.entries()) {
       if (!fragments.has(name)) {
-        fragments.set(name, match.trim());
+        fragments.set(name, frag);
       }
     }
   };
@@ -201,9 +193,17 @@ export async function enrichNotifications(
   if (selections.length === 0) {
     // No handlers with mergeQueryConfig, just enrich individually
     return Promise.all(
-      notifications.map((notification) =>
-        enrichNotification(notification, settings),
-      ),
+      notifications.map(async (notification) => {
+        const handler = createNotificationHandler(notification);
+        const details = await handler.enrich(notification, settings);
+        return {
+          ...notification,
+          subject: {
+            ...notification.subject,
+            ...details,
+          },
+        };
+      }),
     );
   }
 
@@ -212,14 +212,13 @@ export async function enrichNotifications(
     ...Array.from(extraVariableDefinitions.entries()).map(
       ([name, type]) => `$${name}: ${type}`,
     ),
-  ].join(', ');
+  ];
 
-  const mergedQuery = `query FetchMergedNotifications(${combinedVariableDefinitions}) {
-      ${selections.join('\n')}
-    }
-
-    ${Array.from(fragments.values()).join('\n')}
-  `;
+  const mergedQuery = composeMergedQuery(
+    selections,
+    fragments,
+    combinedVariableDefinitions,
+  );
 
   const queryVariables = {
     ...variableValues,
@@ -259,12 +258,14 @@ export async function enrichNotifications(
   const enrichedNotifications = await Promise.all(
     notifications.map(async (notification: Notification) => {
       const target = targets.find((item) => item.notification === notification);
+      const handler =
+        target?.handler ?? createNotificationHandler(notification);
+
+      let fragment: unknown;
       if (mergedData && target) {
-        // Try to find the first defined property in the repoData (pullRequest, issue, discussion, etc.)
         const repoData = mergedData[target.alias] as
           | Record<string, unknown>
           | undefined;
-        let fragment: unknown;
         if (repoData) {
           for (const value of Object.values(repoData)) {
             if (value !== undefined) {
@@ -273,29 +274,14 @@ export async function enrichNotifications(
             }
           }
         }
-        if (fragment) {
-          const details = await target.handler.enrich(
-            notification,
-            settings,
-            fragment,
-          );
-          return {
-            ...notification,
-            subject: {
-              ...notification.subject,
-              ...details,
-            },
-          };
-        }
       }
-      // fallback
-      const handler = createNotificationHandler(notification);
-      const fetchedDetails = await handler.enrich(notification, settings);
+
+      const details = await handler.enrich(notification, settings, fragment);
       return {
         ...notification,
         subject: {
           ...notification.subject,
-          ...fetchedDetails,
+          ...details,
         },
       };
     }),