@preventive/triage 1.0.0-alpha.51 → 1.0.0-alpha.53

package/common/managed/finding-detail.d.ts

@@ -1,3 +1,5 @@
 export const FINDING_DETAIL_FIELDS: readonly string[]
-export function liteReportData(data: unknown, options?: { fold?: boolean }): unknown
-export function liteWorkspace<T extends { filename: string; data: unknown }>(reports: readonly T[], links: readonly (readonly string[])[]): { reports: T[]; folded: boolean }
+export function liteReportData(data: unknown, options?: { fold?: boolean; shown?: ReadonlySet<string> | null }): unknown
+export function liteWorkspace<T extends { filename: string; data: unknown }>(reports: readonly T[], links: readonly (readonly string[])[]): {
+  reports: T[]; folded: false | 'rows' | 'app'; lens: { drop: boolean; detail: boolean; upstream: boolean } | null
+}

package/common/managed/finding-detail.js

@@ -1,5 +1,6 @@
 import { findingTitle, reportEntries, revalidateKindOf } from '@preventive/report'
-import { managedTeamRevalidationConflicted } from './team-app.js'
+import { managedTeamAppRows, managedTeamLens, managedTeamRevalidationConflicted } from './team-app.js'
+import { liteName } from './lite-name.js'
 
 // A finding's detail: what its popup, the views besides the board and an
 // export read, and the board does not. Its narrative and evidence, the hash
@@ -7,21 +8,18 @@ import { managedTeamRevalidationConflicted } from './team-app.js'
 // and an export tell (write-md-finding.js PLAIN_FIELDS, CODE_FIELDS, but for
 // `priority`, which the board sorts and filters by), and the run meta its
 // card's run line and a report's header read (its `model` and `type`, which
-// the board's filters read, stay). A team's
+// the board's filters read, stay), and the link the report gave its location
+// (`location`), which its card does not draw. A team's
 // reports are first sent without it (server-managed/team-reports.ts), the
 // board drawn from them, and their findings filled in from the whole reports
 // (ui/view/managed-details.js).
 export const FINDING_DETAIL_FIELDS = Object.freeze([
   'description', 'evidence', 'impact', 'reproduction', 'recommendation', 'confidenceReason', 'revalidateVerdict', 'revalidateRecommendation',
   'fileHash', 'exportName', 'methodName',
-  'commitHash', 'auditedCommit', 'detectedAt', 'committedAt', 'dateCreated', 'status', 'branch', 'pocStatus', 'parent', 'slug', 'reportPath',
-  'category', 'discoveredIn', 'effort', 'exportsMode',
+  'severityReason', 'commitHash', 'auditedCommit', 'detectedAt', 'committedAt', 'dateCreated', 'status', 'branch', 'pocStatus', 'parent', 'slug', 'reportPath',
+  'category', 'discoveredIn', 'effort', 'exportsMode', 'location',
 ])
 const DETAIL = new Set(FINDING_DETAIL_FIELDS)
-// As much of a name as a heading takes (@preventive/report write-md-finding.js
-// HEADING_MAX), about a board card's three lines.
-const NAME_CHARS = 120
-
 // A finding without its detail. One without a title of its own is named by its
 // description's first line (findingTitle), which it keeps as its description,
 // as much of it as a card shows.
@@ -30,7 +28,7 @@ function liteFinding(finding) {
   const lite = Object.fromEntries(Object.entries(finding).filter(([key]) => !DETAIL.has(key)))
   const titled = typeof finding.title === 'string' && finding.title.trim() !== ''
   const title = titled ? '' : findingTitle(finding)
-  if (title) lite.description = title.length > NAME_CHARS ? `${title.slice(0, NAME_CHARS - 1)}…` : title
+  if (title) lite.description = liteName(title)
   return lite
 }
 
@@ -40,14 +38,20 @@ const isPass = finding => revalidateKindOf(finding) === 'revalidation'
 // App mode shows of an entry holding the revalidation pass's row that row
 // alone (ui/view/group.js foldedTabs): with `fold`, such an entry is sent as
 // the pass's rows, the rows beneath them left for the whole reports
-// (ui/view/managed-details.js).
-export function liteReportData(data, { fold = false } = {}) {
+// (ui/view/managed-details.js). With `shown`, the IDs of the findings one
+// whose App view locks Confirmed shows (common/workspace-app.js
+// workspaceAppRows), those alone are sent.
+export function liteReportData(data, { fold = false, shown = null } = {}) {
   const key = Array.isArray(data?.findings) ? 'findings' : Array.isArray(data?.groups) ? 'groups' : null
   if (!key) return data
+  if (shown) {
+    const kept = entry => (Array.isArray(entry) ? entry : [entry]).filter(finding => shown.has(finding?.id))
+    return { ...data, [key]: data[key].map(kept).filter(entry => entry.length > 0).map(entry => entry.map(liteFinding)) }
+  }
   const entries = data[key].map(entry => {
     if (!Array.isArray(entry)) return liteFinding(entry)
-    const shown = fold && entry.length > 1 && entry.some(isPass) ? entry.filter(isPass) : entry
-    return shown.map(liteFinding)
+    const folded = fold && entry.length > 1 && entry.some(isPass) ? entry.filter(isPass) : entry
+    return folded.map(liteFinding)
   })
   return { ...data, [key]: entries }
 }
@@ -55,12 +59,17 @@ export function liteReportData(data, { fold = false } = {}) {
 const rows = data => (reportEntries(data) ?? []).flat().length
 
 // A team's reports as its board is first sent them (server-managed/team-reports.ts),
-// each `liteReportData`, folded where nothing in the workspace contradicts the
-// revalidation pass, which opens a view of it in App mode
-// (ui/view/render.js configureReportRevalidation); `folded` where that left
-// rows out.
+// each `liteReportData`: where the workspace's App view locks Confirmed, only
+// the rows that view shows (`folded: 'app'`); else, where nothing in it
+// contradicts the revalidation pass, which opens a view of it in App mode
+// (ui/view/render.js configureReportRevalidation), its entries folded under
+// their App rows (`folded: 'rows'`). Folded, the `lens` the rows left out
+// tell (team-app.js managedTeamLens).
 export function liteWorkspace(reports, links) {
-  const fold = !managedTeamRevalidationConflicted(Object.assign(reports.map(({ filename, data }) => ({ filename, data })), { links }))
-  const lite = reports.map(report => ({ ...report, data: liteReportData(report.data, { fold }) }))
-  return { reports: lite, folded: fold && lite.some((report, index) => rows(report.data) < rows(reports[index].data)) }
+  const view = Object.assign(reports.map(({ filename, data }) => ({ filename, data })), { links })
+  const shown = managedTeamAppRows(view)
+  const fold = shown !== null || !managedTeamRevalidationConflicted(view)
+  const lite = reports.map(report => ({ ...report, data: liteReportData(report.data, { fold, shown }) }))
+  if (!fold || !lite.some((report, index) => rows(report.data) < rows(reports[index].data))) return { reports: lite, folded: false, lens: null }
+  return { reports: lite, folded: shown ? 'app' : 'rows', lens: managedTeamLens(view) }
 }

package/common/managed/finding-values.d.ts

@@ -0,0 +1,2 @@
+export function findingValueIndex(): { values: unknown[]; index<T>(data: T): T }
+export function expandFindingValues<T>(data: T, values: unknown): T

package/common/managed/finding-values.js

@@ -0,0 +1,44 @@
+// A finding's `package` and `repo`: the same few across a team's many
+// findings. A team's reports are sent with each once, in the response's
+// `values`, and each finding's as its index there
+// (server-managed/team-reports.ts), put back as they are read
+// (client/managed/session.js).
+const FIELDS = ['package', 'repo']
+
+const entriesKey = data => Array.isArray(data?.findings) ? 'findings' : Array.isArray(data?.groups) ? 'groups' : null
+
+// `values`, and `index(data)`: a report's data with its findings' values as
+// their index in it, one value at one index across every report it is given.
+export function findingValueIndex() {
+  const indexes = new Map(), values = []
+  const indexOf = value => {
+    const key = JSON.stringify(value)
+    if (!indexes.has(key)) indexes.set(key, values.push(value) - 1)
+    return indexes.get(key)
+  }
+  const indexed = finding => {
+    if (!finding || typeof finding !== 'object' || !FIELDS.some(field => finding[field] != null)) return finding
+    const copy = { ...finding }
+    for (const field of FIELDS) if (finding[field] != null) copy[field] = indexOf(finding[field])
+    return copy
+  }
+  return {
+    values,
+    index(data) {
+      const key = entriesKey(data)
+      return key ? { ...data, [key]: data[key].map(entry => Array.isArray(entry) ? entry.map(indexed) : indexed(entry)) } : data
+    },
+  }
+}
+
+// A report's data, as read, its findings' values put in place of their index
+// in a response's `values`; one sent without any as it is.
+export function expandFindingValues(data, values) {
+  const key = entriesKey(data)
+  if (!key || !Array.isArray(values)) return data
+  for (const finding of data[key].flat()) {
+    if (!finding || typeof finding !== 'object') continue
+    for (const field of FIELDS) if (Number.isInteger(finding[field])) finding[field] = values[finding[field]]
+  }
+  return data
+}

package/common/managed/lite-name.d.ts

@@ -0,0 +1,2 @@
+export function liteName(name: string): string
+export function readLiteReportData<T>(data: T): T

package/common/managed/lite-name.js

@@ -0,0 +1,20 @@
+import { reportEntries } from '@preventive/report'
+
+// As much of a name as a heading takes (@preventive/report write-md-finding.js
+// HEADING_MAX), about a board card's three lines. A board's copy of a team's
+// reports (finding-detail.js) cuts one longer to end in `CUT`, an ellipsis
+// once read.
+const CUT = '...', NAME_CHARS = 120
+
+export const liteName = name => name.length > NAME_CHARS ? `${name.slice(0, NAME_CHARS - CUT.length)}${CUT}` : name
+
+// A report's data from its board's copy, as read: a name cut ends in an
+// ellipsis. One as long as a cut leaves it and ending in `CUT` is one; one
+// shorter ends as it does.
+export function readLiteReportData(data) {
+  for (const finding of (reportEntries(data) ?? []).flat()) {
+    const name = finding?.description
+    if (typeof name === 'string' && name.length === NAME_CHARS && name.endsWith(CUT)) finding.description = `${name.slice(0, -CUT.length)}…`
+  }
+  return data
+}

package/common/managed/team-app.d.ts

@@ -4,3 +4,5 @@ export type TeamAppMetadata = { appMode: true; appFindings: number } | { appMode
 export function managedTeamAppMetadata(workspace: readonly { filename: string; data: unknown }[] & { links?: readonly (readonly string[])[] },
   options?: { countFindings?: boolean }): TeamAppMetadata
 export function managedTeamRevalidationConflicted(workspace: readonly { filename: string; data: unknown }[] & { links?: readonly (readonly string[])[] }): boolean
+export function managedTeamAppRows(workspace: readonly { filename: string; data: unknown }[] & { links?: readonly (readonly string[])[] }): Set<string> | null
+export function managedTeamLens(workspace: readonly { filename: string; data: unknown }[] & { links?: readonly (readonly string[])[] }): { drop: boolean; detail: boolean; upstream: boolean }

package/common/managed/team-app.js

@@ -1,7 +1,8 @@
-import { inheritReportMeta, isAppFinding, reportEntries } from '@preventive/report'
+import { inheritReportMeta, isAppFinding, reportEntries, revalidateKindOf } from '@preventive/report'
 import { collectDuplicates } from '../../client/linked-findings.js'
+import { dependencyDirectory, isDependencyFile } from '../../client/dependency-paths.js'
 import { hasRevalidateStamp } from '../finding-filters.js'
-import { workspaceAppMetadata } from '../workspace-app.js'
+import { workspaceAppMetadata, workspaceAppRows } from '../workspace-app.js'
 import { mergeReportGroups } from '../workspace-groups.js'
 
 // The same classification as local workspaces, using only the complete,
@@ -22,6 +23,34 @@ export function managedTeamRevalidationConflicted(workspace) {
   return mergeReportGroups(viewReports(workspace).reports).conflicts.size > 0
 }
 
+// The IDs of the findings the workspace's basic App view can show
+// (common/workspace-app.js workspaceAppRows), or null.
+export function managedTeamAppRows(workspace) {
+  const { reports, duplicates } = viewReports(workspace)
+  return workspaceAppRows(reports, id => [...duplicates.get(id) ?? []])
+}
+
+const RULED_OUT = new Set(['refuted', 'unreachable'])
+
+// What a view of the whole workspace offers beside the App view
+// (ui/view/render.js), told by all its rows: whether the revalidation layer
+// can come off (`drop`), whether its detail stop has rows to unfold
+// (`detail`), and whether an upstream lens has ground (`upstream`).
+export function managedTeamLens(workspace) {
+  const { reports } = viewReports(workspace)
+  const rows = reports.flatMap(report => report.groups.flat())
+  const directory = dependencyDirectory(reports)
+  const detail = mergeReportGroups(reports).groups.some(group => {
+    const kinds = group.map(revalidateKindOf)
+    return kinds.includes('partial') || kinds.includes('revalidation') && kinds.some(kind => kind !== 'revalidation' && !RULED_OUT.has(kind))
+  })
+  return {
+    drop: rows.some(hasRevalidateStamp),
+    detail,
+    upstream: rows.some(f => f.isUpstream === true || f.isApp === false && !('isUpstream' in f) && isDependencyFile(f.file, directory)),
+  }
+}
+
 // The workspace's reports as a view holds them (ui/view/ingest.js), with the
 // duplicates its links name.
 function viewReports(workspace) {
@@ -41,7 +70,7 @@ function viewReports(workspace) {
       finding._sourcePass = judged.has(finding._source)
       return finding
     }))
-    reports.push({ fileName: filename, groups })
+    reports.push({ fileName: filename, groups, treeDependencies: data.treeDependencies ?? null })
   }
   return { reports, duplicates }
 }

package/common/workspace-app.js

@@ -1,5 +1,5 @@
 import { revalidateKindOf } from '@preventive/report'
-import { canLockConfirmed } from './finding-filters.js'
+import { activeRevalidateKinds, canLockConfirmed } from './finding-filters.js'
 import { mergeReportGroups } from './workspace-groups.js'
 import { mergeLinkedWorkspaceGroups } from './linked-workspace-groups.js'
 
@@ -27,13 +27,33 @@ function onlyUnjudgedImports(groups) {
 // `countFindings` has a workspace that is not App count its rows too, after
 // the same merging, for a caller that shows it collapsed (managed teams).
 export function workspaceAppMetadata(reports, duplicatesOf = () => [], { countFindings = false } = {}) {
-  const { groups, conflicts } = mergeReportGroups(reports, { hideRuledOut: true })
-  const linked = mergeLinkedWorkspaceGroups(groups, duplicatesOf, appTabs)
-  const notApp = countFindings ? { appMode: false, findings: linked.length } : { appMode: false }
-  if (conflicts.size > 0) return notApp
-  if (!onlyUnjudgedImports(linked) && !canLockConfirmed(linked, { tabs: appTabs, kindOf: revalidateKindOf, severityMode: 'corrected' })) return notApp
+  const { linked, app } = appView(reports, duplicatesOf)
+  if (!app) return countFindings ? { appMode: false, findings: linked.length } : { appMode: false }
   return {
     appMode: true,
     appFindings: linked.filter((group) => appTabs(group).some((f) => f.isApp)).length,
   }
 }
+
+// The IDs of the findings a workspace's basic App view can show: of each row
+// its locked Confirmed shows (ui/view/filters.js filterRevalidateKind), the
+// App tabs, the rest folded under them; none the pass ruled out. Null where it
+// has no such view, or one with no outcome to lock, which shows every row.
+export function workspaceAppRows(reports, duplicatesOf = () => []) {
+  const { linked, app } = appView(reports, duplicatesOf)
+  if (!app || onlyUnjudgedImports(linked)) return null
+  const kinds = activeRevalidateKinds('confirmed', '')
+  const confirmed = (f) => kinds.includes(revalidateKindOf(f) || (f._source && !f._sourcePass ? 'revalidation' : ''))
+  const ids = new Set()
+  for (const group of linked) if (group.some(confirmed)) for (const f of appTabs(group)) ids.add(f.id)
+  return ids
+}
+
+// A workspace's rows as its basic App view merges them, and whether it has one.
+function appView(reports, duplicatesOf) {
+  const { groups, conflicts } = mergeReportGroups(reports, { hideRuledOut: true })
+  const linked = mergeLinkedWorkspaceGroups(groups, duplicatesOf, appTabs)
+  const app = conflicts.size === 0
+    && (onlyUnjudgedImports(linked) || canLockConfirmed(linked, { tabs: appTabs, kindOf: revalidateKindOf, severityMode: 'corrected' }))
+  return { linked, app }
+}