Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
67 changes: 67 additions & 0 deletions src/main/linear/team-member-order.ts
Original file line number Diff line number Diff line change
@@ -0,0 +1,67 @@
import type { LinearMember } from '../../shared/linear/workspace-types'
import { acquire, release } from './linear-request-concurrency'
import type { LinearClientForWorkspace } from './client'

// Why: one viewer lookup per workspace credential is enough for member ordering;
// entries are replaced on credential rotation so a re-auth as another user refreshes.
const viewerIdCache = new Map<string, { revision: number; viewerId: string }>()
// Why: several dropdowns can request members at once on a cold cache; sharing
// one in-flight lookup avoids redundant viewer calls against the API limiter.
const viewerLookupInFlight = new Map<string, Promise<string | null>>()

export async function getCachedViewerId(entry: LinearClientForWorkspace): Promise<string | null> {
const revision = entry.workspace.credentialRevision ?? 0
const cached = viewerIdCache.get(entry.workspace.id)
if (cached && cached.revision === revision) {
return cached.viewerId
}

const inFlightKey = `${entry.workspace.id}:${revision}`
const inFlight = viewerLookupInFlight.get(inFlightKey)
if (inFlight) {
return inFlight
}

const lookup = (async () => {
await acquire()
try {
const viewer = await entry.client.viewer
viewerIdCache.set(entry.workspace.id, { revision, viewerId: viewer.id })
return viewer.id
} catch (error) {
// Member lists must not fail because the viewer lookup did.
console.warn('[linear] viewer lookup for member ordering failed:', error)
return null
} finally {
release()
viewerLookupInFlight.delete(inFlightKey)
}
})()
viewerLookupInFlight.set(inFlightKey, lookup)
return lookup
}

// Why: host-default collators differ across macOS, Linux, and remote hosts; a
// pinned collator keeps member ordering identical everywhere Orca runs.
const memberNameCollator = new Intl.Collator('en', { sensitivity: 'variant' })

export function sortMembersViewerFirst(
members: LinearMember[],
viewerId: string | null
): LinearMember[] {
return [...members].sort((a, b) => {
if (viewerId) {
if (a.id === viewerId) {
return b.id === viewerId ? 0 : -1
}
if (b.id === viewerId) {
return 1
}
}
return (
memberNameCollator.compare(a.displayName, b.displayName) ||
// Ordinal id tie-break: locale-independent and stable for equal names.
(a.id < b.id ? -1 : a.id > b.id ? 1 : 0)
)
})
}
143 changes: 139 additions & 4 deletions src/main/linear/teams.test.ts
Original file line number Diff line number Diff line change
Expand Up @@ -109,18 +109,23 @@ function makeEntry(
function makeTeamLookupEntry(
workspaceId: string,
organizationName: string,
teamNode: unknown
teamNode: unknown,
options?: { viewer?: () => Promise<{ id: string }>; credentialRevision?: number }
): LinearClientForWorkspace {
return {
workspace: {
id: workspaceId,
organizationId: workspaceId,
organizationName,
displayName: 'Ada',
email: 'ada@example.com'
email: 'ada@example.com',
credentialRevision: options?.credentialRevision
},
client: {
team: vi.fn().mockResolvedValue(teamNode)
team: vi.fn().mockResolvedValue(teamNode),
get viewer() {
return options?.viewer ? options.viewer() : Promise.reject(new Error('no viewer mock'))
}
}
} as unknown as LinearClientForWorkspace
}
Expand Down Expand Up @@ -259,7 +264,14 @@ describe('Linear teams', () => {
[makeMember('user-3', 'Linus')]
])
)
const entry = makeTeamLookupEntry('workspace-1', 'Workspace', { members })
const entry = makeTeamLookupEntry(
'workspace-1',
'Workspace',
{ members },
{
viewer: () => Promise.resolve({ id: 'user-1' })
}
)
getClients.mockReturnValue([entry])
const { getTeamMembersOrThrow } = await import('./teams')

Expand Down Expand Up @@ -315,6 +327,129 @@ describe('Linear teams', () => {
warn.mockRestore()
})

describe('viewer-first member ordering', () => {
beforeEach(() => {
vi.resetModules()
})

function makeMembersEntry(options?: {
viewer?: () => Promise<{ id: string }>
credentialRevision?: number
memberPages?: MemberNode[][]
}): LinearClientForWorkspace {
const members = vi.fn().mockResolvedValue(
makeConnection(
options?.memberPages ?? [
[makeMember('user-1', 'brian'), makeMember('user-2', 'pika')],
[makeMember('user-3', 'andrew'), makeMember('user-4', 'sean')]
]
)
)
return makeTeamLookupEntry('workspace-1', 'Workspace', { members }, options)
}

it('pins the viewer first and alpha-sorts the rest', async () => {
const viewer = vi.fn().mockResolvedValue({ id: 'user-3' })
getClients.mockReturnValue([makeMembersEntry({ viewer })])
const { getTeamMembersOrThrow } = await import('./teams')

await expect(getTeamMembersOrThrow('team-1', 'workspace-1')).resolves.toMatchObject([
{ id: 'user-3', displayName: 'andrew' },
{ id: 'user-1', displayName: 'brian' },
{ id: 'user-2', displayName: 'pika' },
{ id: 'user-4', displayName: 'sean' }
])
})

it('alpha-sorts when the viewer is not a team member', async () => {
const viewer = vi.fn().mockResolvedValue({ id: 'user-elsewhere' })
getClients.mockReturnValue([makeMembersEntry({ viewer })])
const { getTeamMembers } = await import('./teams')

await expect(getTeamMembers('team-1', 'workspace-1')).resolves.toMatchObject([
{ id: 'user-3' },
{ id: 'user-1' },
{ id: 'user-2' },
{ id: 'user-4' }
])
})

it('falls back to alpha order when the viewer lookup fails', async () => {
const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
try {
const viewer = vi.fn().mockRejectedValue(new Error('viewer down'))
getClients.mockReturnValue([makeMembersEntry({ viewer })])
const { getTeamMembersOrThrow } = await import('./teams')

await expect(getTeamMembersOrThrow('team-1', 'workspace-1')).resolves.toMatchObject([
{ id: 'user-3' },
{ id: 'user-1' },
{ id: 'user-2' },
{ id: 'user-4' }
])
expect(warn).toHaveBeenCalledWith(
expect.stringContaining('viewer lookup'),
expect.any(Error)
)
} finally {
warn.mockRestore()
}
})

it('shares one in-flight viewer lookup across concurrent member fetches', async () => {
let resolveViewer: (value: { id: string }) => void = () => {}
const viewer = vi.fn().mockImplementation(
() =>
new Promise<{ id: string }>((resolve) => {
resolveViewer = resolve
})
)
getClients.mockReturnValue([makeMembersEntry({ viewer })])
const { getTeamMembersOrThrow } = await import('./teams')

const first = getTeamMembersOrThrow('team-1', 'workspace-1')
const second = getTeamMembersOrThrow('team-1', 'workspace-1')
await vi.waitFor(() => expect(viewer).toHaveBeenCalledTimes(1))
resolveViewer({ id: 'user-3' })

const expectedOrder = [{ id: 'user-3' }, { id: 'user-1' }, { id: 'user-2' }, { id: 'user-4' }]
await expect(first).resolves.toMatchObject(expectedOrder)
await expect(second).resolves.toMatchObject(expectedOrder)
expect(viewer).toHaveBeenCalledTimes(1)
})

it('caches the viewer id per workspace credential revision', async () => {
const viewer = vi.fn().mockResolvedValue({ id: 'user-3' })
getClients.mockReturnValue([makeMembersEntry({ viewer, credentialRevision: 1 })])
const { getTeamMembersOrThrow } = await import('./teams')

await getTeamMembersOrThrow('team-1', 'workspace-1')
await getTeamMembersOrThrow('team-1', 'workspace-1')
expect(viewer).toHaveBeenCalledTimes(1)

// Credential rotation invalidates the cached viewer id.
getClients.mockReturnValue([makeMembersEntry({ viewer, credentialRevision: 2 })])
await getTeamMembersOrThrow('team-1', 'workspace-1')
expect(viewer).toHaveBeenCalledTimes(2)
})

it('sorts members deterministically with duplicate display names', async () => {
const { sortMembersViewerFirst } = await import('./team-member-order')

expect(sortMembersViewerFirst([], null)).toEqual([])
expect(
sortMembersViewerFirst(
[
{ id: 'user-b', displayName: 'sam' },
{ id: 'user-a', displayName: 'sam' },
{ id: 'user-c', displayName: 'alex' }
],
'user-b'
)
).toMatchObject([{ id: 'user-b' }, { id: 'user-c' }, { id: 'user-a' }])
})
})

it('surfaces Linear credential decrypt errors on active team reads', async () => {
const error = new Error(credentialDecryptionMessage('Linear'))
getClients.mockImplementation(() => {
Expand Down
19 changes: 17 additions & 2 deletions src/main/linear/teams.ts
Original file line number Diff line number Diff line change
Expand Up @@ -10,6 +10,7 @@ import type {
import { acquire, release } from './linear-request-concurrency'
import { clearToken } from './linear-token-store'
import { getClients, isAuthError } from './client'
import { getCachedViewerId, sortMembersViewerFirst } from './team-member-order'
import {
fetchAllTeamLabels,
fetchAllTeamMembers,
Expand Down Expand Up @@ -140,6 +141,20 @@ async function readTeamResource<T>(
}
}

async function readTeamMembersViewerFirst(
teamId: string,
workspaceId: string | null | undefined,
fallbackWarning?: string
): Promise<LinearMember[]> {
const entry = getClients(workspaceId)[0]
if (!entry) {
return []
}
const viewerId = await getCachedViewerId(entry)
const members = await readTeamResource(teamId, workspaceId, fetchAllTeamMembers, fallbackWarning)
return sortMembersViewerFirst(members, viewerId)
}

export async function getTeamStates(
teamId: string,
workspaceId?: string | null
Expand Down Expand Up @@ -172,14 +187,14 @@ export async function getTeamMembers(
teamId: string,
workspaceId?: string | null
): Promise<LinearMember[]> {
return readTeamResource(teamId, workspaceId, fetchAllTeamMembers, 'getTeamMembers')
return readTeamMembersViewerFirst(teamId, workspaceId, 'getTeamMembers')
}

export async function getTeamMembersOrThrow(
teamId: string,
workspaceId?: string | null
): Promise<LinearMember[]> {
return readTeamResource(teamId, workspaceId, fetchAllTeamMembers)
return readTeamMembersViewerFirst(teamId, workspaceId)
}

export async function getViewerForWorkspaceOrThrow(
Expand Down