@wmfs/lerna-sync 1.38.0 → 1.39.0

package/.circleci/config.yml

@@ -65,6 +65,27 @@ jobs:
           key: v1-deps-{{ checksum "package.json" }}
           paths:
             - node_modules
+      - run:
+          name: get github app token
+          command: |
+            node -e '
+              const crypto = require("crypto");
+              const key = Buffer.from(process.env.GH_APP_PRIVATE_KEY_B64, "base64").toString();
+              const b64 = o => Buffer.from(JSON.stringify(o)).toString("base64url");
+              const now = Math.floor(Date.now() / 1000);
+              const unsigned = b64({ alg: "RS256", typ: "JWT" }) + "." +
+                b64({ iat: now - 60, exp: now + 540, iss: process.env.GH_APP_ID });
+              const jwt = unsigned + "." + crypto.sign("RSA-SHA256", Buffer.from(unsigned), key).toString("base64url");
+              const headers = { Authorization: `Bearer ${jwt}`, Accept: "application/vnd.github+json" };
+              const repo = `${process.env.CIRCLE_PROJECT_USERNAME}/${process.env.CIRCLE_PROJECT_REPONAME}`;
+              (async () => {
+                const inst = await (await fetch(`https://api.github.com/repos/${repo}/installation`, { headers })).json();
+                const res = await (await fetch(`https://api.github.com/app/installations/${inst.id}/access_tokens`, { method: "POST", headers })).json();
+                if (!res.token) { console.error(inst, res); process.exit(1); }
+                console.log(`export GH_TOKEN=${res.token}`);
+                console.log(`export GIT_CREDENTIALS=x-access-token:${res.token}`);
+              })();
+            ' >> "$BASH_ENV"
       - run:
           name: release
           command: npx semantic-release

package/CHANGELOG.md

@@ -1,3 +1,18 @@
+## [1.39.0](https://github.com/wmfs/lerna-sync/compare/v1.38.0...v1.39.0) (2026-10-22)
+
+### New Feature(s) :rocket:
+
+* [sc-33783] Improve Lerna Sync scalability ([#222](https://github.com/wmfs/lerna-sync/issues/222)) ([74ee189](https://github.com/wmfs/lerna-sync/commit/74ee189080c367190ae28c7c405158c310c94b14))
+* try new token approach ([#225](https://github.com/wmfs/lerna-sync/issues/225)) ([bff962d](https://github.com/wmfs/lerna-sync/commit/bff962d8ebdced954dd10833dc2e89edb63c7326))
+
+### Build system dependencies :hammer:
+
+* **deps-dev:** update dependency mocha to v12.0.3 ([#224](https://github.com/wmfs/lerna-sync/issues/224)) ([c4ab8d3](https://github.com/wmfs/lerna-sync/commit/c4ab8d3f7adffd28be01616edc71422687a232f8))
+
+### CICD Configuration Changes :construction_worker:
+
+* new step in config.yml ([76154e6](https://github.com/wmfs/lerna-sync/commit/76154e6c6962dcd938d7d3c2e94019849251fe3a))
+
 ## [1.38.0](https://github.com/wmfs/lerna-sync/compare/v1.37.1...v1.38.0) (2026-09-30)
 
 ### Bug Fix(es) :bug:

package/README.md

@@ -21,99 +21,187 @@ A package to synchronize distributed GitHub repos inside a Lerna monorepo.
 
 **This is the situation *lerna-sync* is designed to help with.** :smiley:
 
-## Install Lerna
+## How it works
 
-You'll need to have [Node.js](https://nodejs.org/en/download/) installed and [Lerna](https://github.com/lerna/lerna) available **globally**:
+You keep an **empty husk** of a monorepo: a `lerna.json` and a set of empty package directories. Our [tymly](https://github.com/wmfs/tymly) repo is an example. Each time you sync, lerna-sync:
+
+1. **Discovers** every repo in your GitHub organization with one paginated GraphQL query, collecting each repo's default branch, latest commit and `package.json`. Archived repos and forks are skipped.
+2. **Inspects** the directories already in your monorepo: which are git repos, which branch is checked out, and whether there are local changes or a merge or rebase in progress.
+3. **Plans** what to do with every repo, using your [routing function](#routing-function) to decide which repos belong in the monorepo and where.
+4. **Executes** the plan, running git in parallel, and prints a summary of what happened and what needs your attention.
+
+### What happens to each repo
+
+lerna-sync never creates merge commits and never touches a branch you're working on.
+
+| Local state | What lerna-sync does |
+| ----------- | -------------------- |
+| Not cloned yet | Clones it into the directory the routing function chose |
+| On the default branch, clean | Fetches, then fast-forwards (`git merge --ff-only`) |
+| On another branch | Fetches only. Your branch and working tree are left alone, and the report lists any new commits on the default branch for you to merge or rebase yourself. Your local default branch is fast-forwarded in the background when that's safe. |
+| Detached HEAD | Fetches only, as above |
+| Uncommitted changes on the default branch | Fetches only, and reports how far behind it is |
+| Unpushed commits, or diverged from GitHub | Fetches only, and reports it |
+| Untracked files that an update would overwrite | Doesn't update, and reports it |
+| Mid-merge or mid-rebase | Leaves it alone, and reports it |
+| A directory that isn't a git repo | Leaves it alone. Never clones over it. |
+| `origin` points at a different owner (e.g. a personal fork) | Leaves it alone, and reports it |
+| No longer in the org, or no longer selected by the routing function | Leaves it alone, and lists it under *Housekeeping* |
+| In a different directory from the one the routing function now chooses | Updates it as normal, with a warning. Never moves it. |
+
+Each repo's **default branch is read from GitHub**, so repos using `main` work as well as those using `master`.
+
+## Requirements
+
+* [Node.js](https://nodejs.org/en/download/) 20 or later.
+* [Git](https://git-scm.com/downloads) on your `PATH`.
+* A **[GitHub access token](https://github.com/settings/tokens)** that can read your organization's repos (see [Credentials](#credentials)).
+
+## Installation
 
 ``` bash
-npm install lerna -g
+npm install @wmfs/lerna-sync --save
 ```
 
-## The monorepo husk
+## Usage
 
-Create an **empty husk** of a Lerna Monorepo (our [tymly](https://github.com/wmfs/tymly) repo is an example).
+``` javascript
+const path = require('path')
+const LernaSync = require('@wmfs/lerna-sync')
+
+async function main () {
+  const lernaSync = new LernaSync({
+    monorepoPath: path.resolve(__dirname, '..'),
+    gitHubToken: process.env.MY_GITHUB_TOKEN,
+    gitHubOrgName: 'wmfs',
+    lernaPackageRouterFunction: routePackage
+  })
+
+  const { errorCount } = await lernaSync.sync()
+  if (errorCount > 0) process.exitCode = 1
+}
 
-*Some things:*
+main().catch(err => {
+  console.error(err)
+  process.exitCode = 1
+})
+```
 
-* Note that the directories you'd ordinarily expect Lerna packages to be living inside, are empty.
-* The [lerna.json](https://github.com/wmfs/tymly/blob/master/lerna.json) file is pretty basic stuff.
+See [tymly/lib/sync.js](https://github.com/wmfs/tymly/blob/master/lib/sync.js) for a complete example, including command-line flags.
 
-This is the the empty husk of your monorepo, it should be committed and pretty much forgotten about after this point.
+### Options
 
-## GitHub Credentials
+| Option | Required | Default | Notes |
+| ------ | -------- | ------- | ----- |
+| `monorepoPath` | Yes | | Path to the monorepo husk: the directory containing `lerna.json`. |
+| `gitHubToken` | Yes | | Token used to query the GitHub API. |
+| `gitHubOrgName` | Yes | | The GitHub organization to sync from, e.g. `wmfs`. |
+| `lernaPackageRouterFunction` | Yes | | Decides which repos to sync and where. See [Routing function](#routing-function). |
+| `dryRun` | No | `false` | Plan and print what would happen, without running any git commands that change anything. |
+| `verbose` | No | `false` | Also list every repo that was ignored, with the reason. |
+| `concurrency` | No | `8` when inspecting, `6` for git network operations | How many repos to work on at once. Lower it on slow disks or connections. |
+| `cloneUrl` | No | `https://github.com/<org>/<repo>.git` | `(orgName, repoName) => url`. Use it to clone over SSH, e.g. `` (org, name) => `git@github.com:${org}/${name}.git` ``. |
+| `updateLocalDefaultBranch` | No | `true` | When you're on another branch, also fast-forward your local default branch if it can be done safely. |
 
-Lerna-sync will take-on the work to clone/pull your separate GitHub repos and keep them in-sync within your monorepo.
+### Return value
 
-**You'll need to provide some GitHub credentials to hand, namely:**
+`sync()` resolves with:
 
-* Your GitHub **username**.
-* A **[GitHub Access Token](https://github.com/settings/tokens)** associated with the provided **username**. Giving your token a description of "*Lerna Sync Access*" will be fine. This is necessary to avoid certain rate-limits and access private repos. Remember to keep tokens private and treat them as if they were passwords.
-* A name of a GitHub **organization** that your Lerna packages will be synchronized with (for example `wmfs`).
+``` javascript
+{
+  plan,           // every decision lerna-sync made, with its reason
+  results,        // what happened for each repo that git was run on (empty on a dry run)
+  errorCount,     // repos where git failed
+  attentionCount  // repos that need you to look at them
+}
+```
 
+Use `errorCount` to set your script's exit code.
 
 ## Routing function
 
-You may have many GitHub repos in the organization you specify that shouldn't come anywhere near your monorepo.
-Also, you might like to take advantage of Lerna's support for multiple-package directories to help structure things a bit better.
+Your organization probably has repos that shouldn't come anywhere near your monorepo. You might also want to use Lerna's support for multiple package directories to give things some structure.
 
-In **lerna-sync** this filtering/routing can be achieved via a simple Javascript function. Here's an example:
+The routing function handles both. lerna-sync calls it once for each repo in the organization that has a valid `package.json`, passing that `package.json` as a parsed object. Repos with no `package.json` are skipped without calling it.
+
+It should return one of:
+
+* **A directory name**, such as `'plugins'`, to sync the repo into that directory. It must match an entry in the `packages` array of the monorepo's `lerna.json` (`'plugins'` for `"plugins/*"`). If it doesn't, the repo is ignored and the reason says so.
+* **`{ skip: 'reason' }`** to leave the repo out and say why. The reason appears in the report, which helps when someone expects a repo that isn't there.
+* **`null` or `undefined`** to leave the repo out silently. Use this for repos that are nothing to do with the monorepo.
+
+If the function throws, that repo is ignored with the error as its reason, and the rest of the sync carries on.
 
 ``` javascript
-// Here we use look at the keywords array in the repo's package.json
-// to decide which monorepo package directory (if any) it should belong.
-
-function (gitHubPackageObj) {
-  // [string-in-keywords, monorepo-directory-name]
-  const keywordToPackageMap = [
-    ['package', 'packages'],
-    ['plugin', 'plugins'],
-    ['blueprint', 'blueprints'],
-    ['cardscript', 'cardscript'],
-    ['app', 'apps']
-  ]
-  if (gitHubPackageObj.hasOwnProperty('keywords') && gitHubPackageObj.keywords.indexOf('tymly') !== -1) {
-    let lernaPackageName = null
-    const keywords = gitHubPackageObj.keywords
-    keywordToPackageMap.forEach(
-      tuple => {
-        if (keywords.indexOf(tuple[0]) !== -1) {
-          lernaPackageName = tuple[1]
-        }
-      }
-    )
-    return lernaPackageName
+// Use keywords in each repo's package.json to pick its directory.
+// The first matching keyword wins.
+const KEYWORD_FOLDERS = [
+  ['blueprint', 'blueprints'],
+  ['plugin', 'plugins'],
+  ['package', 'packages']
+]
+
+function routePackage (pkg) {
+  const keywords = Array.isArray(pkg.keywords) ? pkg.keywords : []
+  if (!keywords.includes('tymly')) return null
+
+  if (pkg.config && pkg.config.tymly && pkg.config.tymly.sync === false) {
+    return { skip: 'Opted out (config.tymly.sync = false)' }
   }
+
+  const match = KEYWORD_FOLDERS.find(([keyword]) => keywords.includes(keyword))
+  return match ? match[1] : { skip: 'No folder keyword' }
 }
 ```
 
-Lerna-sync will call this function with the `package.json` content (already parsed as a JavaScript object) of each repo in the source GitHub organization.
+## The report
+
+As each repo finishes, lerna-sync prints a progress line, then a summary grouped by what you need to do:
+
+```
+Downloading repo information from https://github.com/wmfs
+  Cloned      plugins/tymly-rbac-plugin
+  On branch   plugins/tymly-pg-plugin  (feature/connection-pool, master has 1 new commit)
+  Updated     plugins/tymly-core  (pulled 1 commit)
+
+Cloned (1)
+  plugins/tymly-rbac-plugin Plugin for Tymly
+
+Updated (1)
+  plugins/tymly-core 1 new commit
+    ff3037f fix: handle missing state machine (Jane Smith, 2 hours ago)
 
-* Any repos with no `package.json` will be skipped entirely due to not being a suitable candidate for a Lerna Monorepo.
+Needs your attention (1)
+  plugins/tymly-pg-plugin On feature/connection-pool: master has 1 commit(s) you don't
+    8ccdfe1 feat: support schema search paths (Jane Smith, 3 hours ago)
 
-The function should return the name of a directory registered in the `packages` array in the monorepo's [`lerna.json`](https://github.com/wmfs/tymly/blob/master/lerna.json) file.
+1 up to date, 1 cloned, 1 updated, 1 need attention, 0 errors
 
-* If no value is returned by this function, then **lerna-sync** will know not to route the repo to any package directory (i.e. it's filtered out).
+Dependencies may have changed. Reinstall/relink before running anything.
+
+Done (14 seconds).
+```
 
------
+The possible sections are *Cloned*, *Updated*, *On branches (left alone)*, *Needs your attention*, *Housekeeping* and *Errors*. The reminder about dependencies only appears when a repo was cloned or an update changed a `package.json`.
 
-WIP
+## Credentials
 
-# Environment variables
+lerna-sync uses credentials in two separate places:
 
-| Variable | Notes |
-| -------- | ----- |
-| `LERNA_SYNC_MONOREPO_PATH` | Should be set to a directory where a `lerna.json` can be found. |
-| `LERNA_SYNC_GITHUB_TOKEN`	 | Generate a new GitHub token [here](https://github.com/settings/tokens), a description of "lerna-sync connection" will do.
-| `LERNA_SYNC_GITHUB_ORG`    | Name of the GitHub organization holding all your repos. |
-| `LERNA_SYNC_GITHUB_USER`   | Your GitHub username (used in conjunction with `LERNA_SYNC_GITHUB_TOKEN` to fetch/pull repos. |
+* **The GitHub API** (discovering repos) uses `gitHubToken`. A classic token needs the **repo** scope to see private repos. A fine-grained token needs read access to **Contents** and **Metadata** for the organization's repos. Without that, private repos are silently missing from the results.
+* **Git** (clone and fetch) uses **your own git credentials**, not the token. For HTTPS, set up a credential helper such as [Git Credential Manager](https://github.com/git-ecosystem/git-credential-manager) or run `gh auth setup-git`. For SSH, use the `cloneUrl` option and make sure your key is loaded in `ssh-agent`.
 
-# Installation
+Because many git commands run in parallel with their output captured, lerna-sync runs git non-interactively. A missing credential makes that repo fail with an error instead of waiting for a password prompt nobody can see. Each git command also has a 5-minute timeout. A credential manager that opens its own sign-in window can still do so.
+
+## Development
 
 ``` bash
-npm install @wmfs/lerna-sync --save
+npm test     # mocha with coverage (nyc)
+npm run lint # standard
 ```
 
-## <a name="Usage"></a> Usage
+The tests need git on your `PATH` but no network access or GitHub token. Tests that exercise git create throwaway repos in your temp directory, using local bare repos as the "GitHub" origin, and ignore your global git config.
+
+## License
 
-## <a name='license'></a>License
-[MIT](https://github.com/wmfs/lerna-sync/blob/master/LICENSE)
+[MIT](https://github.com/wmfs/lerna-sync/blob/master/LICENSE)

package/lib/discover.js

@@ -0,0 +1,52 @@
+const query = require('./github-graphql-query')
+const chalk = require('chalk')
+
+function parsePackageJson (repoName, blob) {
+  if (!blob || typeof blob.text !== 'string') return null
+  if (blob.isTruncated) {
+    console.warn(chalk.yellow(`package.json for ${repoName} was truncated, skipping`))
+    return null
+  }
+  try {
+    return JSON.parse(blob.text)
+  } catch (e) {
+    console.warn(chalk.yellow(`Unable to parse package.json for ${repoName}`))
+    return null
+  }
+}
+
+module.exports = async function discover (graphql, org) {
+  const repos = []
+  let after = null
+
+  console.log(chalk.gray(`Downloading repo information from https://github.com/${org}`))
+
+  do {
+    const { organization } = await graphql(query.orgRepos, { org, after })
+    const { nodes, pageInfo } = organization.repositories
+
+    for (const node of nodes) {
+      if (node.isArchived) continue // belt and braces
+
+      const branch = node.defaultBranchRef
+      if (!branch) continue // empty repo, nothing to sync
+
+      const commit = branch.target
+      const blob = node.packageJson
+
+      repos.push({
+        name: node.name,
+        isPrivate: node.isPrivate,
+        defaultBranch: branch.name,
+        sha: commit.oid,
+        messageHeadline: commit.messageHeadline,
+        author: commit.author,
+        packageJson: parsePackageJson(node.name, blob)
+      })
+    }
+
+    after = pageInfo.hasNextPage ? pageInfo.endCursor : null
+  } while (after)
+
+  return repos
+}

package/lib/execute-plan.js

@@ -0,0 +1,141 @@
+const path = require('path')
+const { git, tryGit } = require('./utils/git')
+const mapLimit = require('./utils/map-limit')
+const { ACTIONS, REASONS } = require('./plan-sync')
+
+const OUTCOMES = Object.freeze({
+  CLONED: 'CLONED',
+  UPDATED: 'UPDATED',
+  CURRENT: 'CURRENT',
+  BEHIND: 'BEHIND', // fetched only; the default branch has commits HEAD doesn't
+  LOCAL_AHEAD: 'LOCAL_AHEAD', // unpushed commits on the default branch
+  DIVERGED: 'DIVERGED',
+  BLOCKED_BY_UNTRACKED: 'BLOCKED_BY_UNTRACKED',
+  FAILED: 'FAILED'
+})
+
+const HANDLERS = {
+  [ACTIONS.CLONE]: cloneRepo,
+  [ACTIONS.FAST_FORWARD]: fastForward,
+  [ACTIONS.FETCH_ONLY]: fetchOnly
+}
+
+async function executePlan (plan, options) {
+  const runnable = plan.decisions.filter(d => d.action !== ACTIONS.NONE)
+
+  return mapLimit(runnable, options.concurrency || 6, async decision => {
+    let result
+    try {
+      result = { decision, ...(await HANDLERS[decision.action](decision, options)) }
+    } catch (err) {
+      result = { decision, outcome: OUTCOMES.FAILED, error: cleanError(err) }
+    }
+    if (options.onResult) options.onResult(result) // progress line as each one finishes
+    return result
+  })
+}
+
+async function cloneRepo (d, { monorepoPath, gitHubOrgName, cloneUrl }) {
+  const dest = path.join(monorepoPath, ...d.folder.split('/'), d.remote.name)
+  const url = cloneUrl
+    ? cloneUrl(gitHubOrgName, d.remote.name) // e.g. allow SSH: git@github.com:wmfs/x.git
+    : `https://github.com/${gitHubOrgName}/${d.remote.name}.git`
+
+  await git(['clone', '--quiet', url, dest], monorepoPath)
+  return { outcome: OUTCOMES.CLONED }
+}
+
+async function fastForward (d) {
+  const cwd = d.local.path
+  const upstream = `origin/${d.defaultBranch}`
+
+  await gitFetch(cwd)
+  const { ahead, behind } = await aheadBehind(cwd, upstream)
+
+  if (behind === 0) {
+    return { outcome: ahead > 0 ? OUTCOMES.LOCAL_AHEAD : OUTCOMES.CURRENT, ahead, behind }
+  }
+  if (ahead > 0) {
+    return { outcome: OUTCOMES.DIVERGED, ahead, behind, commits: await incoming(cwd, upstream) }
+  }
+
+  const commits = await incoming(cwd, upstream)
+  const before = await git(['rev-parse', 'HEAD'], cwd)
+
+  try {
+    await git(['merge', '--ff-only', '--quiet', upstream], cwd)
+  } catch (err) {
+    if (/untracked working tree files would be overwritten/i.test(err.stderr || '')) {
+      return { outcome: OUTCOMES.BLOCKED_BY_UNTRACKED, ahead, behind, commits }
+    }
+    throw err
+  }
+
+  const changed = await git(['diff', '--name-only', before, 'HEAD', '--', 'package.json'], cwd)
+  return { outcome: OUTCOMES.UPDATED, ahead, behind, commits, packageJsonChanged: changed.length > 0 }
+}
+
+async function fetchOnly (d, { updateLocalDefaultBranch = true }) {
+  const cwd = d.local.path
+  const upstream = `origin/${d.defaultBranch}`
+
+  await gitFetch(cwd)
+
+  // On a feature branch or detached HEAD, local master isn't checked out, so it can be
+  // fast-forwarded without touching the working tree. Skip it for LOCAL_CHANGES:
+  // there, master *is* checked out.
+  if (updateLocalDefaultBranch && d.reason !== REASONS.LOCAL_CHANGES) {
+    await fastForwardRef(cwd, d.defaultBranch, upstream)
+  }
+
+  const { ahead, behind } = await aheadBehind(cwd, upstream)
+  return {
+    outcome: behind > 0 ? OUTCOMES.BEHIND : OUTCOMES.CURRENT,
+    ahead,
+    behind,
+    commits: behind > 0 ? await incoming(cwd, upstream) : []
+  }
+}
+
+// Helpers
+
+const gitFetch = cwd => git(['fetch', '--quiet', '--prune', 'origin'], cwd)
+
+async function aheadBehind (cwd, upstream) {
+  const out = await git(['rev-list', '--left-right', '--count', `HEAD...${upstream}`], cwd)
+  const [ahead, behind] = out.split(/\s+/).map(Number)
+  return { ahead, behind }
+}
+
+async function incoming (cwd, upstream, limit = 10) {
+  const out = await git(
+    ['log', `--max-count=${limit}`, '--format=%h%x09%an%x09%ar%x09%s', `HEAD..${upstream}`],
+    cwd
+  )
+  if (!out) return []
+  return out.split('\n').map(line => {
+    const [sha, author, when, subject] = line.split('\t')
+    return { sha, author, when, subject }
+  })
+}
+
+async function fastForwardRef (cwd, branch, upstream) {
+  const ref = `refs/heads/${branch}`
+  const current = await tryGit(['rev-parse', '--verify', '--quiet', ref], cwd)
+  if (!current) return // no local master branch, nothing to update
+
+  // Exit code 0 only if local master is an ancestor of origin/master, i.e. a fast-forward
+  const isFastForward = await tryGit(['merge-base', '--is-ancestor', ref, upstream], cwd)
+  if (isFastForward === null) return
+
+  // Passing the old SHA makes this a compare-and-swap
+  await tryGit(['update-ref', ref, upstream, current], cwd)
+}
+
+function cleanError (err) {
+  if (err.killed) return err.message // e.g. "git fetch timed out after 300s"
+  const text = (err.stderr || err.message || String(err)).trim()
+  return text.split('\n').slice(-3).join('\n')
+}
+
+module.exports = { executePlan, OUTCOMES }

package/lib/github-graphql-query.js

@@ -1,41 +1,44 @@
-module.exports = `
-    query myOrgRepos($queryString: String!, $afterValue: String) {
-        search(query: $queryString, type: REPOSITORY, first: 100, after: $afterValue) {
-            pageInfo {
-                startCursor
-                hasNextPage
-                endCursor
+module.exports = {
+  orgRepos: `
+    query orgRepos($org: String!, $after: String) {
+      organization(login: $org) {
+        repositories(
+          first: 100
+          after: $after
+          isFork: false
+          isArchived: false
+          orderBy: { field: NAME, direction: ASC }
+        ) {
+          pageInfo {
+            hasNextPage
+            endCursor
+          }
+          nodes {
+            name
+            isArchived
+            isPrivate
+            packageJson: object(expression: "HEAD:package.json") {
+              ... on Blob {
+                text
+                isTruncated
+              }
             }
-            edges {
-                node {
-                    ... on Repository {
-                        name
-                        object(expression: "master:package.json") {
-                            ... on Blob {
-                                text
-                            }
-                        }
-                        ref(qualifiedName: "master") {
-                            target {
-                                ... on Commit {
-                                    history(first: 1) {
-                                        edges {
-                                            node {
-                                                oid                            
-                                                messageHeadline,
-                                                author {
-                                                    name
-                                                    date
-                                                }
-                                            }
-                                        }
-                                    }                      
-                                }
-                            }
-                        }
-                    }          
+            defaultBranchRef {
+              name
+              target {
+                ... on Commit {
+                  oid
+                  messageHeadline
+                  author {
+                    name
+                    date
+                  }
                 }
+              }
             }
+          }
         }
+      }
     }
-`
+  `
+}