fix: add remote branches to repo graph

Author: tranhl

dist/index.js

@@ -21,6 +21,7 @@
     "@actions/exec": "^1.1.1",
     "@actions/github": "^6.0.0",
     "graphology": "^0.25.4",
+    "graphology-dag": "^0.4.1",
     "graphology-traversal": "^0.3.1",
     "remark": "^15.0.1",
     "remark-gfm": "^4.0.0",

package-lock.json

@@ -136,6 +136,7 @@ describe('getCurrentPullRequest', () => {
           number: 100,
           base: { ref: 'main' },
           head: { ref: 'feat/git-town-action' },
+          state: 'open',
         },
       },
     } as unknown as typeof github.context
@@ -144,8 +145,9 @@ describe('getCurrentPullRequest', () => {
 
     expect(currentPullRequest).toStrictEqual({
       number: 100,
-      baseRefName: 'main',
-      headRefName: 'feat/git-town-action',
+      base: { ref: 'main' },
+      head: { ref: 'feat/git-town-action' },
+      state: 'open',
     })
   })
 

package.json

@@ -103,31 +103,21 @@ export const inputs = {
 
   getCurrentPullRequest(context: typeof github.context) {
     try {
-      const pullRequest:
-        | {
-            number: number
-            base?: { ref?: string }
-            head?: { ref?: string }
-          }
-        | undefined = context.payload.pull_request
+      const pullRequest = pullRequestSchema.parse(context.payload.pull_request)
 
       core.startGroup('Inputs: Current pull request')
       core.info(JSON.stringify(pullRequest))
       core.endGroup()
 
-      return pullRequestSchema.parse({
-        number: pullRequest?.number,
-        baseRefName: pullRequest?.base?.ref,
-        headRefName: pullRequest?.head?.ref,
-      })
+      return pullRequest
     } catch (error) {
       core.setFailed(`Unable to determine current pull request from action payload`)
       throw error
     }
   },
 
   async getPullRequests(octokit: Octokit, context: typeof github.context) {
-    const openPullRequests = await octokit.paginate(
+    const pullRequests = await octokit.paginate(
       'GET /repos/{owner}/{repo}/pulls',
       {
         ...context.repo,
@@ -138,19 +128,21 @@ export const inputs = {
         response.data.map(
           (item): PullRequest => ({
             number: item.number,
-            baseRefName: item.base.ref,
-            headRefName: item.head.ref,
+            base: { ref: item.base.ref },
+            head: { ref: item.head.ref },
             body: item.body ?? undefined,
+            state: item.state,
           })
         )
     )
+    pullRequests.sort((a, b) => b.number - a.number)
 
     core.startGroup('Inputs: Pull requests')
     core.info(
-      JSON.stringify(openPullRequests.map(({ body: _, ...pullRequest }) => pullRequest))
+      JSON.stringify(pullRequests.map(({ body: _, ...pullRequest }) => pullRequest))
     )
     core.endGroup()
 
-    return openPullRequests
+    return pullRequests
   },
 }

src/inputs.test.ts

@@ -1,5 +1,6 @@
 import { describe, it, beforeEach, expect, vi } from 'vitest'
-import { updateDescription } from './main'
+import { main, updateDescription } from './main'
+import type { Octokit } from './types'
 
 beforeEach(() => {
   vi.unstubAllEnvs()
@@ -52,3 +53,46 @@ describe('updateDescription', () => {
     expect(actual).toEqual(expected)
   })
 })
+
+describe('main', () => {
+  it('should work', async () => {
+    await main({
+      octokit: {} as unknown as Octokit,
+      currentPullRequest: {
+        number: 361,
+        head: {
+          ref: 'test-branch',
+        },
+        base: {
+          ref: 'document-setup',
+        },
+        state: 'open',
+      },
+      pullRequests: [
+        // {
+        //   number: 360,
+        //   head: {
+        //     ref: 'document-setup',
+        //   },
+        //   base: {
+        //     ref: 'main',
+        //   },
+        //   state: 'open',
+        // },
+        {
+          number: 361,
+          head: {
+            ref: 'test-branch',
+          },
+          base: {
+            ref: 'document-setup',
+          },
+          state: 'open',
+        },
+      ],
+      mainBranch: 'main',
+      perennialBranches: [],
+      skipSingleStacks: false,
+    })
+  })
+})

src/inputs.ts

@@ -1,7 +1,8 @@
 import * as core from '@actions/core'
 import * as github from '@actions/github'
-import { MultiDirectedGraph } from 'graphology'
-import { bfsFromNode, dfs, dfsFromNode } from 'graphology-traversal'
+import { DirectedGraph } from 'graphology'
+import { bfsFromNode, dfsFromNode } from 'graphology-traversal'
+import { topologicalSort } from 'graphology-dag'
 import type { PullRequest, Context, StackNodeAttributes } from './types'
 import { remark } from './remark'
 
@@ -13,65 +14,104 @@ export async function main({
   perennialBranches,
   skipSingleStacks,
 }: Context) {
-  const repoGraph = new MultiDirectedGraph<StackNodeAttributes>()
+  const repoGraph = new DirectedGraph<StackNodeAttributes>()
 
-  repoGraph.addNode(mainBranch, {
+  repoGraph.mergeNode(mainBranch, {
     type: 'perennial',
     ref: mainBranch,
   })
 
   perennialBranches.forEach((perennialBranch) => {
-    repoGraph.addNode(perennialBranch, {
+    repoGraph.mergeNode(perennialBranch, {
       type: 'perennial',
       ref: perennialBranch,
     })
   })
 
-  pullRequests.forEach((pullRequest) => {
-    repoGraph.addNode(pullRequest.headRefName, {
+  const openPullRequests = pullRequests.filter(
+    (pullRequest) => pullRequest.state === 'open'
+  )
+
+  openPullRequests.forEach((openPullRequest) => {
+    repoGraph.mergeNode(openPullRequest.head.ref, {
       type: 'pull-request',
-      ...pullRequest,
+      ...openPullRequest,
     })
   })
 
-  pullRequests.forEach((pullRequest) => {
-    repoGraph.addDirectedEdge(pullRequest.baseRefName, pullRequest.headRefName)
+  openPullRequests.forEach((openPullRequest) => {
+    const hasExistingBasePullRequest = repoGraph.hasNode(openPullRequest.base.ref)
+    if (hasExistingBasePullRequest) {
+      repoGraph.mergeDirectedEdge(openPullRequest.base.ref, openPullRequest.head.ref)
+
+      return
+    }
+
+    const basePullRequest = pullRequests.find(
+      (basePullRequest) => basePullRequest.head.ref === openPullRequest.base.ref
+    )
+    if (basePullRequest?.state === 'closed') {
+      repoGraph.mergeNode(openPullRequest.base.ref, {
+        type: 'pull-request',
+        ...basePullRequest,
+      })
+      repoGraph.mergeDirectedEdge(openPullRequest.base.ref, openPullRequest.head.ref)
+
+      return
+    }
+
+    repoGraph.mergeNode(openPullRequest.base.ref, {
+      type: 'orphan-branch',
+      ref: openPullRequest.base.ref,
+    })
+    repoGraph.mergeDirectedEdge(openPullRequest.base.ref, openPullRequest.head.ref)
   })
 
+  const terminatingRefs = [mainBranch, ...perennialBranches]
+
   const getStackGraph = (pullRequest: PullRequest) => {
-    const stackGraph = repoGraph.copy() as MultiDirectedGraph<StackNodeAttributes>
-    stackGraph.setNodeAttribute(pullRequest.headRefName, 'isCurrent', true)
+    const stackGraph = repoGraph.copy() as DirectedGraph<StackNodeAttributes>
+    stackGraph.setNodeAttribute(pullRequest.head.ref, 'isCurrent', true)
 
     bfsFromNode(
       stackGraph,
-      pullRequest.headRefName,
+      pullRequest.head.ref,
       (ref, attributes) => {
         stackGraph.setNodeAttribute(ref, 'shouldPrint', true)
-        return attributes.type === 'perennial'
+        return attributes.type === 'perennial' || attributes.type === 'orphan-branch'
       },
-      {
-        mode: 'inbound',
-      }
+      { mode: 'inbound' }
     )
 
     dfsFromNode(
       stackGraph,
-      pullRequest.headRefName,
+      pullRequest.head.ref,
       (ref) => {
         stackGraph.setNodeAttribute(ref, 'shouldPrint', true)
       },
       { mode: 'outbound' }
     )
 
-    return stackGraph
+    stackGraph.forEachNode((ref, stackNode) => {
+      if (!stackNode.shouldPrint) {
+        stackGraph.dropNode(ref)
+      }
+    })
+
+    return DirectedGraph.from(stackGraph.toJSON())
   }
 
-  const getOutput = (graph: MultiDirectedGraph<StackNodeAttributes>) => {
+  const getOutput = (graph: DirectedGraph<StackNodeAttributes>) => {
     const lines: string[] = []
-    const terminatingRefs = [mainBranch, ...perennialBranches]
 
-    dfs(
+    // `dfs` is bugged and doesn't traverse in topological order.
+    // `dfsFromNode` does, so we'll do the topological sort ourselves
+    // start traversal from the root.
+    const rootRef = topologicalSort(graph)[0]
+
+    dfsFromNode(
       graph,
+      rootRef,
       (_, stackNode, depth) => {
         if (!stackNode.shouldPrint) return
 
@@ -80,6 +120,10 @@ export async function main({
 
         let line = indentation
 
+        if (stackNode.type === 'orphan-branch') {
+          line += `- \`${stackNode.ref}\` - :warning: No PR associated with branch`
+        }
+
         if (stackNode.type === 'perennial' && terminatingRefs.includes(stackNode.ref)) {
           line += `- \`${stackNode.ref}\``
         }
@@ -100,12 +144,10 @@ export async function main({
     return lines.join('\n')
   }
 
-  const jobs: Array<() => Promise<void>> = []
-
   const stackGraph = getStackGraph(currentPullRequest)
 
   const shouldSkip = () => {
-    const neighbors = stackGraph.neighbors(currentPullRequest.headRefName)
+    const neighbors = stackGraph.neighbors(currentPullRequest.head.ref)
     const allPerennialBranches = stackGraph.filterNodes(
       (_, nodeAttributes) => nodeAttributes.type === 'perennial'
     )
@@ -121,6 +163,8 @@ export async function main({
     return
   }
 
+  const jobs: Array<() => Promise<void>> = []
+
   stackGraph.forEachNode((_, stackNode) => {
     if (stackNode.type !== 'pull-request' || !stackNode.shouldPrint) {
       return

src/main.test.ts

@@ -6,8 +6,13 @@ export type Octokit = ReturnType<typeof getOctokit>
 
 export const pullRequestSchema = object({
   number: number(),
-  baseRefName: string(),
-  headRefName: string(),
+  base: object({
+    ref: string(),
+  }),
+  head: object({
+    ref: string(),
+  }),
+  state: string(),
   body: string().optional(),
 })
 export type PullRequest = InferType<typeof pullRequestSchema>
@@ -22,6 +27,10 @@ export type Context = {
 }
 
 export type StackNode =
+  | {
+      type: 'orphan-branch'
+      ref: string
+    }
   | {
       type: 'perennial'
       ref: string