🐛 GraphQL workflow processing fixes (#129)

Author: stoe

src/github/repository.js

@@ -281,32 +281,25 @@ export default class Repository extends Base {
       const [o, n] = repoName.split('/')
 
       const {
-        data: {
-          data: {
-            repository: {
-              nwo,
-              owner: {login: owner},
-              name,
-              id,
-              node_id,
-              visibility,
-              isArchived,
-              isFork,
-              defaultBranchRef,
-            },
-          },
+        repository: {
+          nwo,
+          owner: {login: owner},
+          name,
+          id,
+          node_id,
+          visibility,
+          isArchived,
+          isFork,
+          defaultBranchRef,
         },
-      } = await this.octokit.request('POST /graphql', {
-        query: REPO_QUERY,
-        variables: {owner: o, name: n},
-      })
+      } = await this.octokit.graphql(REPO_QUERY, {owner: o, name: n})
 
       this.#nwo = nwo
       this.#owner = owner
       this.#name = name
       this.#repo = {
-        owner: owner.login,
-        name: name,
+        owner,
+        name,
       }
       this.#id = id
       this.#node_id = node_id
@@ -353,16 +346,9 @@ export default class Repository extends Base {
     this.spinner.text = `Loading workflows for repository ${cyan(`${owner}/${repo}`)}...`
 
     try {
-      const {
-        data: {
-          data: {repository},
-        },
-      } = await this.octokit.request('POST /graphql', {
-        query: WORKFLOWS_QUERY,
-        variables: {
-          owner,
-          name: repo,
-        },
+      const {repository} = await this.octokit.graphql(WORKFLOWS_QUERY, {
+        owner,
+        name: repo,
       })
 
       const wfs = []

src/report/report.js

@@ -653,7 +653,10 @@ export default class Report {
   processWorkflow(wf, repo, reportTotalCounts) {
     const {language, text, yaml} = wf
 
-    if (language !== 'YAML') {
+    // Robust language check:
+    // - If a language value is provided and it's not 'YAML', and we also do NOT have a parsed yaml object, skip.
+    // - If language is null/undefined but we have a yaml object, proceed (some APIs may omit language metadata).
+    if (language && language !== 'YAML' && !yaml) {
       this.#logger.warn(
         `Skipping workflow ${wf.path} in repository ${repo.nwo} due to unsupported language: ${language}`,
       )

test/github/repository.test.js

@@ -126,113 +126,112 @@ describe('repository', () => {
    */
   describe('workflow operations', () => {
     beforeEach(() => {
-      // Mock the octokit requests
-      repository.octokit.request = jest.fn()
+      // Mock the octokit GraphQL client
       repository.octokit.graphql = jest.fn()
     })
 
     test('should fetch workflows for repository', async () => {
-      const mockGraphQLResponse = {
-        data: {
-          data: {
-            repository: {
-              object: {
-                entries: [
-                  {
-                    name: 'ci.yml',
-                    path: '.github/workflows/ci.yml',
-                    language: {name: 'YAML'},
-                    object: {
-                      text: 'name: CI\non: push',
-                      isTruncated: false,
-                    },
-                  },
-                  {
-                    name: 'release.yml',
-                    path: '.github/workflows/release.yml',
-                    language: {name: 'YAML'},
-                    object: {
-                      text: 'name: Release\non: release',
-                      isTruncated: false,
-                    },
-                  },
-                ],
+      repository.octokit.graphql.mockResolvedValueOnce({
+        repository: {
+          object: {
+            entries: [
+              {
+                name: 'ci.yml',
+                path: '.github/workflows/ci.yml',
+                language: {name: 'YAML'},
+                object: {text: 'name: CI\non: push', isTruncated: false, node_id: '1'},
               },
-            },
+              {
+                name: 'release.yml',
+                path: '.github/workflows/release.yml',
+                language: {name: 'YAML'},
+                object: {text: 'name: Release\non: release', isTruncated: false, node_id: '2'},
+              },
+            ],
           },
         },
-      }
+      })
 
-      repository.octokit.request.mockResolvedValue(mockGraphQLResponse)
+      // Mock the REST workflow detail & runs requests invoked by Workflow#getWorkflow
+      repository.octokit.request = jest
+        .fn()
+        // First workflow detail
+        .mockResolvedValueOnce({
+          data: {
+            id: 101,
+            node_id: 'W_flow_101',
+            name: 'CI',
+            path: '.github/workflows/ci.yml',
+            state: 'active',
+            created_at: '2024-01-01T00:00:00Z',
+            updated_at: '2024-01-02T00:00:00Z',
+          },
+        })
+        // First workflow runs (only most recent run needed)
+        .mockResolvedValueOnce({
+          data: {
+            workflow_runs: [{updated_at: '2024-01-03T00:00:00Z'}],
+          },
+        })
+        // Second workflow detail
+        .mockResolvedValueOnce({
+          data: {
+            id: 202,
+            node_id: 'W_flow_202',
+            name: 'Release',
+            path: '.github/workflows/release.yml',
+            state: 'active',
+            created_at: '2024-02-01T00:00:00Z',
+            updated_at: '2024-02-02T00:00:00Z',
+          },
+        })
+        // Second workflow runs
+        .mockResolvedValueOnce({
+          data: {
+            workflow_runs: [{updated_at: '2024-02-03T00:00:00Z'}],
+          },
+        })
 
       const workflows = await repository.getWorkflows('mona', 'sample-repo')
 
       expect(Array.isArray(workflows)).toBe(true)
-      // Since the actual implementation will depend on Workflow constructor,
-      // we just verify that the method runs without error
-      expect(workflows).toBeDefined()
+      expect(workflows).toHaveLength(2)
     })
 
     test('should handle repositories without workflows', async () => {
-      const mockGraphQLResponse = {
-        data: {
-          data: {
-            repository: {
-              object: null,
-            },
-          },
-        },
-      }
-
-      repository.octokit.request.mockResolvedValueOnce(mockGraphQLResponse)
+      repository.octokit.graphql.mockResolvedValueOnce({
+        repository: {object: null},
+      })
 
       const workflows = await repository.getWorkflows('mona', 'sample-repo')
-
       expect(Array.isArray(workflows)).toBe(true)
       expect(workflows).toHaveLength(0)
     })
 
     test('should handle empty workflow directory', async () => {
-      const mockGraphQLResponse = {
-        data: {
-          data: {
-            repository: {
-              object: {
-                entries: [],
-              },
-            },
-          },
-        },
-      }
-
-      repository.octokit.request.mockResolvedValueOnce(mockGraphQLResponse)
+      repository.octokit.graphql.mockResolvedValueOnce({
+        repository: {object: {entries: []}},
+      })
 
       const workflows = await repository.getWorkflows('mona', 'sample-repo')
-
       expect(Array.isArray(workflows)).toBe(true)
       expect(workflows).toHaveLength(0)
     })
 
     test('should fetch repository metadata', async () => {
-      const mockRepoData = {
-        data: {
-          data: {
-            repository: {
-              nwo: 'mona/sample-repo',
-              owner: {login: 'mona'},
-              name: 'sample-repo',
-              id: 123,
-              node_id: 'MDEwOlJlcG9zaXRvcnkx',
-              visibility: 'PUBLIC',
-              isArchived: false,
-              isFork: false,
-              defaultBranchRef: {name: 'main'},
-            },
-          },
+      repository.octokit.graphql.mockResolvedValueOnce({
+        repository: {
+          nwo: 'mona/sample-repo',
+          owner: {login: 'mona'},
+          name: 'sample-repo',
+          id: 123,
+          node_id: 'MDEwOlJlcG9zaXRvcnkx',
+          visibility: 'PUBLIC',
+          isArchived: false,
+          isFork: false,
+          defaultBranchRef: {name: 'main'},
         },
-      }
-
-      repository.octokit.request.mockResolvedValueOnce(mockRepoData)
+      })
 
       const result = await repository.getRepo('mona/sample-repo')
 
@@ -242,6 +241,7 @@ describe('repository', () => {
       expect(result.visibility).toBe('PUBLIC')
       expect(result.isArchived).toBe(false)
       expect(result.isFork).toBe(false)
+      expect(result.branch).toBe('main')
     })
 
     test('should handle API errors when fetching workflows', async () => {
@@ -255,7 +255,7 @@ describe('repository', () => {
         },
       }
 
-      repository.octokit.request.mockResolvedValueOnce(mockGraphQLResponse)
+      repository.octokit.graphql.mockResolvedValueOnce(mockGraphQLResponse)
 
       const workflows = await repository.getWorkflows('mona', 'sample-repo')
       expect(Array.isArray(workflows)).toBe(true)

test/report/report-extraction.test.js

@@ -113,4 +113,68 @@ describe('Report extraction end-to-end (regression)', () => {
     expect(wf.vars instanceof Set && wf.vars.size).toBeGreaterThan(0)
     expect(wf.uses instanceof Set && wf.uses.size).toBeGreaterThan(0)
   })
+
+  test('should process workflow when language is null but yaml object exists', async () => {
+    const flags = {
+      token: 'TEST',
+      repository: 'o/r',
+      csv: null,
+      json: null,
+      md: null,
+      listeners: true,
+      permissions: true,
+      runsOn: true,
+      secrets: true,
+      vars: true,
+      uses: true,
+      unique: 'false',
+    }
+
+    const report = new Report(flags, mockLogger(), mockCache())
+
+    const wf = createWorkflow()
+    wf.language = null // simulate missing language metadata
+
+    const data = await report.createReport({workflows: [wf]})
+    expect(data).toHaveLength(1)
+    expect(data[0].name).toBe('CI Full')
+  })
+
+  test('should skip workflow when language is non-YAML and yaml object missing', async () => {
+    const flags = {
+      token: 'TEST',
+      repository: 'o/r',
+      csv: null,
+      json: null,
+      md: null,
+      listeners: true,
+      permissions: true,
+      runsOn: true,
+      secrets: true,
+      vars: true,
+      uses: true,
+      unique: 'false',
+    }
+
+    const report = new Report(flags, mockLogger(), mockCache())
+
+    const invalidWf = {
+      node_id: 'WF_node_invalid',
+      path: '.github/workflows/script.js',
+      language: 'JavaScript',
+      text: 'console.log("hi")',
+      yaml: null,
+      state: 'active',
+      created_at: new Date().toISOString(),
+      updated_at: new Date().toISOString(),
+      last_run_at: new Date().toISOString(),
+    }
+
+    const validWf = createWorkflow()
+
+    const data = await report.createReport({workflows: [invalidWf, validWf]})
+    // Only the valid YAML workflow should be processed
+    expect(data).toHaveLength(1)
+    expect(data[0].workflow).toBe('.github/workflows/ci.yml')
+  })
 })