@crombolo/api-management 0.10.0 → 0.12.1

package/src/handlers/diagnostics.ts

@@ -0,0 +1,89 @@
+/**
+ * Health checks, telemetry, profiling and the server's troubleshooting and
+ * upgrade-check answers. Telemetry and profiling are fixed: nothing is
+ * collected or sent, and there is no profiler. docs/diagnostics.md.
+ */
+import { invalidSkipTake, notFound, problemDetails, problemResponse } from '@crombolo/core'
+import type { DiagnosticsPort } from '../ports-diagnostics.ts'
+import type { ManagementApiRouter } from '../router.ts'
+import { paging } from './content-type.ts'
+import { readBody } from './document.ts'
+
+const TELEMETRY_LEVEL = 'Minimal'
+
+const badRequest = (title: string, detail: string) => problemDetails({ title, detail, status: 400 })
+
+export function registerTelemetryAndProfilingHandlers(router: ManagementApiRouter): void {
+  router.handle('GetTelemetry', (ctx) => {
+    const page = paging(ctx)
+    if (!page) return problemResponse(invalidSkipTake())
+    const items = [{ telemetryLevel: TELEMETRY_LEVEL }]
+    return Response.json({
+      total: items.length,
+      items: items.slice(page.skip, page.skip + page.take),
+    })
+  })
+  router.handle('GetTelemetryLevel', () => Response.json({ telemetryLevel: TELEMETRY_LEVEL }))
+  router.handle('PostTelemetryLevel', async (ctx) => {
+    const { telemetryLevel } = await readBody(ctx)
+    if (telemetryLevel === TELEMETRY_LEVEL) return new Response(null, { status: 200 })
+    return problemResponse(
+      badRequest(
+        'Telemetry cannot be raised',
+        'This site collects no telemetry and sends nothing anywhere, so the level stays at Minimal.',
+      ),
+    )
+  })
+  router.handle('GetProfilingStatus', () => Response.json({ enabled: false }))
+  router.handle('PutProfilingStatus', async (ctx) => {
+    const { enabled } = await readBody(ctx)
+    if (enabled === false) return new Response(null, { status: 200 })
+    return problemResponse(
+      badRequest('Profiling is not available', 'This site has no profiler to switch on.'),
+    )
+  })
+}
+
+export function registerDiagnosticsHandlers(
+  router: ManagementApiRouter,
+  diagnostics: DiagnosticsPort,
+): void {
+  const groupNamed = (name: string) =>
+    diagnostics.groups().find((group) => group.name.toLowerCase() === name.toLowerCase())
+  const noGroup = () => problemResponse(notFound('The health check group could not be found'))
+
+  router.handle('GetHealthCheckGroup', (ctx) => {
+    const page = paging(ctx)
+    if (!page) return problemResponse(invalidSkipTake())
+    const groups = diagnostics.groups()
+    return Response.json({
+      total: groups.length,
+      items: groups.slice(page.skip, page.skip + page.take).map(({ name }) => ({ name })),
+    })
+  })
+  router.handle('GetHealthCheckGroupByName', (ctx) => {
+    const group = groupNamed(String(ctx.params.name))
+    return group ? Response.json(group) : noGroup()
+  })
+  router.handle('PostHealthCheckGroupByNameCheck', async (ctx) => {
+    const group = groupNamed(String(ctx.params.name))
+    const checks = group && (await diagnostics.run(group.name))
+    return checks ? Response.json({ checks }) : noGroup()
+  })
+  // No check here offers an action: each one reports, and the fix is a change
+  // to the site's configuration rather than something a button can do.
+  router.handle('PostHealthCheckExecuteAction', () =>
+    problemResponse(
+      badRequest(
+        'There is nothing to run',
+        'These health checks report only; none offers an action.',
+      ),
+    ),
+  )
+  router.handle('GetServerTroubleshooting', async () =>
+    Response.json(await diagnostics.troubleshooting()),
+  )
+  router.handle('GetServerUpgradeCheck', async () =>
+    Response.json(await diagnostics.upgradeCheck()),
+  )
+}

package/src/handlers/document-blueprint.ts

@@ -7,7 +7,7 @@ import { invalidSkipTake, notFound, problemDetails, problemResponse } from '@cro
 import type { BlueprintPort, PortFailure } from '../ports-content.ts'
 import type { ManagementApiRouter, RequestContext } from '../router.ts'
 import { created, paging, registerFolderHandlers } from './content-type.ts'
-import { auditLogResponse, readBody, toDocumentResponse, toSaveDocument } from './document.ts'
+import { readBody, toDocumentResponse, toSaveDocument } from './document.ts'
 
 const API = '/umbraco/management/api/v1'
 
@@ -126,8 +126,6 @@ export function registerDocumentBlueprintHandlers(
     return new Response(null, { status: 200 })
   })
 
-  router.handle('GetDocumentBlueprintByIdAuditLog', (ctx) => auditLogResponse(ctx, port))
-
   router.handle('GetDocumentTypeByIdBlueprint', async (ctx) => {
     const page = paging(ctx)
     if (!page) return problemResponse(invalidSkipTake())

package/src/handlers/document.ts

@@ -7,11 +7,14 @@ import type {
   DocumentTreeItem,
   DocumentValidationError,
   DocumentValue,
-  DocumentVersionSummary,
+  PatchOperation,
 } from '@crombolo/core'
 import {
+  applyJsonPatch,
+  DocumentPermissions,
   invalidSkipTake,
   notFound,
+  permissionsForPath,
   problemDetails,
   problemResponse,
   ROOT_ACCESS,
@@ -24,6 +27,7 @@ import {
   type TreeSource,
   visibleChildren,
   visibleRoot,
+  visibleSearch,
   visibleSiblings,
 } from './start-node-trees.ts'
 
@@ -385,11 +389,28 @@ export function registerDocumentHandlers(
     const page = paging(ctx)
     if (!page) return problemResponse(invalidSkipTake())
     const query = ctx.url.searchParams.get('query') ?? ''
-    const result = await port.search(query, {
-      ...page,
-      trashed: ctx.url.searchParams.get('trashed') === 'true',
-      parentKey: ctx.url.searchParams.get('parentId'),
-    })
+    const groups = ctx.principal?.groups ?? []
+    // Browse is checked per item only when some group could withhold it somewhere.
+    const browsesEverything =
+      !ctx.principal ||
+      groups.some(
+        (group) =>
+          group.defaults.includes(DocumentPermissions.Read) &&
+          [...group.granular.values()].every((verbs) => verbs.includes(DocumentPermissions.Read)),
+      )
+    const result = await visibleSearch(
+      documentStart(ctx),
+      browsesEverything
+        ? undefined
+        : (chain) => permissionsForPath(groups, chain).has(DocumentPermissions.Read),
+      (paging) =>
+        port.search(query, {
+          ...paging,
+          trashed: ctx.url.searchParams.get('trashed') === 'true',
+          parentKey: ctx.url.searchParams.get('parentId'),
+        }),
+      page,
+    )
     return Response.json({ total: result.total, items: result.items.map(toDocumentItemResponse) })
   })
 
@@ -452,11 +473,12 @@ export function registerDocumentHandlers(
     return created(`${ctx.url.origin}/umbraco/management/api/v1/document/${result.key}`, result.key)
   })
 
-  router.handle('PutDocumentById', async (ctx) => {
-    const key = ctx.params.id as string
-    const existing = await port.byKey(key)
-    if (!existing) return problemResponse(notFound('The document could not be found'))
-    const body = await readBody(ctx)
+  const saveUpdate = async (
+    ctx: RequestContext,
+    key: string,
+    existing: DocumentAggregate,
+    body: Record<string, unknown>,
+  ) => {
     const result = await port.update(
       key,
       {
@@ -477,6 +499,48 @@ export function registerDocumentHandlers(
     }
     ctx.notifications.push({ message: 'Document saved', category: 'Content', type: 'Success' })
     return new Response(null, { status: 200 })
+  }
+
+  router.handle('PutDocumentById', async (ctx) => {
+    const key = ctx.params.id as string
+    const existing = await port.byKey(key)
+    if (!existing) return problemResponse(notFound('The document could not be found'))
+    return saveUpdate(ctx, key, existing, await readBody(ctx))
+  })
+
+  // JSON Patch over the update model, Umbraco's filter segments included; the
+  // patched model then saves exactly as a PUT would.
+  router.handle('PatchDocumentByIdPatch', async (ctx) => {
+    const key = ctx.params.id as string
+    const existing = await port.byKey(key)
+    if (!existing) return problemResponse(notFound('The document could not be found'))
+    const invalid = (detail: string, status = 400) =>
+      problemResponse(problemDetails({ title: 'Could not patch the document', status, detail }))
+    const { operations } = await readBody(ctx)
+    if (!Array.isArray(operations) || operations.length === 0)
+      return invalid('A patch needs at least one operation.')
+    const current = {
+      template: existing.componentKey ? { id: existing.componentKey } : null,
+      values: existing.values.map(({ alias, culture, segment, value }) => ({
+        alias,
+        culture,
+        segment,
+        value,
+      })),
+      variants: existing.variants.map(({ culture, segment, name }) => ({ culture, segment, name })),
+    }
+    const patched = applyJsonPatch(current, operations as PatchOperation[])
+    if (!patched.ok) return invalid(patched.reason)
+    const body = patched.value as Record<string, unknown>
+    if (!Array.isArray(body.values) || !Array.isArray(body.variants))
+      return invalid('A patch may change values and variants, but not remove them.')
+    const aliases = new Set((await port.propertyAliases?.(key)) ?? [])
+    const unknown = (body.values as Array<{ alias?: unknown }>).find(
+      (value) => !aliases.has(String(value?.alias)),
+    )
+    if (unknown)
+      return invalid(`This document's type has no property "${String(unknown.alias)}".`, 422)
+    return saveUpdate(ctx, key, existing, body)
   })
 
   router.handle('PutDocumentByIdPublish', async (ctx) => {
@@ -849,7 +913,6 @@ export function registerDocumentHandlers(
   })
 
   /** The page's history, from its versions: who saved, published or rolled back, and when. */
-  router.handle('GetDocumentByIdAuditLog', (ctx) => auditLogResponse(ctx, port))
 
   router.handle('GetDocumentVersion', async (ctx) => {
     const documentId = ctx.url.searchParams.get('documentId')
@@ -922,40 +985,3 @@ export function registerDocumentHandlers(
     })
   })
 }
-
-const AUDIT_TYPE = {
-  save: 'Save',
-  publish: 'Publish',
-  rollback: 'RollBack',
-  migrate: 'System',
-} as const
-
-/** An audit log built from an item's versions, paged and filtered as the contract asks. */
-export async function auditLogResponse(
-  ctx: RequestContext,
-  port: {
-    versions(key: string): Promise<DocumentVersionSummary[]>
-    systemUserKey(): Promise<string | null>
-  },
-): Promise<Response> {
-  const page = paging(ctx)
-  if (!page) return problemResponse(invalidSkipTake())
-  const since = ctx.url.searchParams.get('sinceDate')
-  const sinceTime = since ? Date.parse(since) : Number.NaN
-  let versions = await port.versions(ctx.params.id as string)
-  if (!Number.isNaN(sinceTime))
-    versions = versions.filter((v) => v.versionDate.getTime() >= sinceTime)
-  if (ctx.url.searchParams.get('orderDirection') === 'Ascending') versions = versions.reverse()
-  const fallbackUser = await port.systemUserKey()
-  const window = versions.slice(page.skip, page.skip + page.take)
-  return Response.json({
-    total: versions.length,
-    items: window.map((version) => ({
-      user: { id: version.userKey ?? fallbackUser },
-      timestamp: version.versionDate.toISOString(),
-      logType: AUDIT_TYPE[version.kind ?? 'save'],
-      comment: null,
-      parameters: null,
-    })),
-  })
-}

package/src/handlers/dynamic-root.ts

@@ -0,0 +1,63 @@
+/**
+ * Dynamic roots: a content picker's start node, resolved from the document being
+ * edited by an origin and a list of steps.
+ */
+import { problemDetails, problemResponse } from '@crombolo/core'
+import type { DynamicRootPort } from '../ports.ts'
+import type { ManagementApiRouter } from '../router.ts'
+import { readBody } from './document.ts'
+
+export const DYNAMIC_ROOT_STEP_ALIASES = [
+  'NearestAncestorOrSelf',
+  'FurthestAncestorOrSelf',
+  'NearestDescendantOrSelf',
+  'FurthestDescendantOrSelf',
+]
+
+const EMPTY_GUID = '00000000-0000-0000-0000-000000000000'
+
+const keyOf = (value: unknown): string | null => {
+  const id = (value as { id?: unknown } | null | undefined)?.id ?? value
+  return typeof id === 'string' && id !== '' && id !== EMPTY_GUID ? id : null
+}
+
+export function registerDynamicRootHandlers(
+  router: ManagementApiRouter,
+  port: DynamicRootPort,
+): void {
+  router.handle('GetDynamicRootSteps', () => Response.json(DYNAMIC_ROOT_STEP_ALIASES))
+  router.handle('PostDynamicRootQuery', async (ctx) => {
+    const body = await readBody(ctx)
+    const context = body.context as { id?: unknown; parent?: unknown } | undefined
+    const query = body.query as
+      | { origin?: { alias?: unknown; id?: unknown }; steps?: unknown }
+      | undefined
+    if (!context || typeof query?.origin?.alias !== 'string')
+      return problemResponse(
+        problemDetails({
+          title: 'Invalid dynamic root query',
+          detail: 'A query needs a context and an origin.',
+          status: 400,
+        }),
+      )
+    const steps = Array.isArray(query.steps) ? query.steps : []
+    const roots = await port.resolve({
+      currentKey: keyOf(context.id),
+      parentKey: keyOf(context.parent),
+      origin: { alias: query.origin.alias, key: keyOf(query.origin.id) },
+      steps: steps.map((step) => {
+        const { alias, documentTypeIds } = (step ?? {}) as {
+          alias?: unknown
+          documentTypeIds?: unknown
+        }
+        return {
+          alias: String(alias ?? ''),
+          documentTypeKeys: Array.isArray(documentTypeIds)
+            ? documentTypeIds.filter((id): id is string => typeof id === 'string')
+            : [],
+        }
+      }),
+    })
+    return Response.json({ roots })
+  })
+}

package/src/handlers/element.ts

@@ -17,7 +17,7 @@ import { invalidSkipTake, notFound, problemDetails, problemResponse } from '@cro
 import type { ElementPort, PortFailure, ReferencePort } from '../ports-content.ts'
 import type { ManagementApiRouter, RequestContext } from '../router.ts'
 import { created, paging, registerFolderHandlers } from './content-type.ts'
-import { auditLogResponse, failureResponse, readBody, toSaveDocument } from './document.ts'
+import { failureResponse, readBody, toSaveDocument } from './document.ts'
 
 const API = '/umbraco/management/api/v1'
 
@@ -444,7 +444,6 @@ export function registerElementHandlers(
     })
 
   // ── history ───────────────────────────────────────────────────────────────
-  handle('GetElementByIdAuditLog', (ctx) => auditLogResponse(ctx, port))
 
   handle('GetElementVersion', async (ctx) => {
     const elementId = ctx.url.searchParams.get('elementId')

package/src/handlers/media.ts

@@ -13,8 +13,8 @@ import {
 import type { MediaPort, PortFailure } from '../ports-content.ts'
 import type { ManagementApiRouter, RequestContext } from '../router.ts'
 import { created, paging } from './content-type.ts'
-import { auditLogResponse, readBody, toSaveDocument, validationProblem } from './document.ts'
-import { visibleChildren, visibleRoot, visibleSiblings } from './start-node-trees.ts'
+import { readBody, toSaveDocument, validationProblem } from './document.ts'
+import { visibleChildren, visibleRoot, visibleSearch, visibleSiblings } from './start-node-trees.ts'
 
 const API = '/umbraco/management/api/v1'
 
@@ -251,8 +251,6 @@ export function registerMediaHandlers(router: ManagementApiRouter, port: MediaPo
   router.handle('PutMediaByIdSortChildren', (ctx) => sortByField(ctx, ctx.params.id as string))
   router.handle('PutMediaRootSortChildren', (ctx) => sortByField(ctx, null))
 
-  router.handle('GetMediaByIdAuditLog', (ctx) => auditLogResponse(ctx, port))
-
   /** Thumbnail and crop URLs in the query vocabulary the media route understands. */
   router.handle('GetImagingResizeUrls', async (ctx) => {
     const params = new URLSearchParams()
@@ -341,11 +339,17 @@ export function registerMediaHandlers(router: ManagementApiRouter, port: MediaPo
     const page = paging(ctx)
     if (!page) return problemResponse(invalidSkipTake())
     const parentId = ctx.url.searchParams.get('parentId')
-    const result = await port.search(ctx.url.searchParams.get('query') ?? '', {
-      trashed: ctx.url.searchParams.get('trashed') === 'true',
-      parentKey: parentId,
-      ...page,
-    })
+    const result = await visibleSearch(
+      mediaStart(ctx),
+      undefined,
+      (paging) =>
+        port.search(ctx.url.searchParams.get('query') ?? '', {
+          trashed: ctx.url.searchParams.get('trashed') === 'true',
+          parentKey: parentId,
+          ...paging,
+        }),
+      page,
+    )
     return Response.json({ total: result.total, items: result.items.map(toMediaItem) })
   })
 

package/src/handlers/reference-data.ts

@@ -0,0 +1,35 @@
+/**
+ * Fixed reference answers: the node object types a relation type can join, and
+ * the help pages. Umbraco relays its help pages from our.umbraco.com; there is
+ * nothing to relay here, so the list is honestly empty.
+ */
+import { invalidSkipTake, ObjectTypes, problemResponse } from '@crombolo/core'
+import type { ManagementApiRouter } from '../router.ts'
+import { paging } from './content-type.ts'
+
+/** Internal markers rather than things a relation can point at. */
+const HIDDEN = new Set<string>(['SystemRoot', 'LockObject'])
+
+/** `DocumentTypeContainer` → `Document Type Container`. */
+const spaced = (name: string) => name.replace(/([a-z])([A-Z])/g, '$1 $2')
+
+export const OBJECT_TYPES = Object.entries(ObjectTypes)
+  .filter(([name]) => !HIDDEN.has(name))
+  .map(([name, id]) => ({ id, name: spaced(name) }))
+  .sort((a, b) => a.name.localeCompare(b.name))
+
+export function registerReferenceDataHandlers(router: ManagementApiRouter): void {
+  router.handle('GetObjectTypes', (ctx) => {
+    const page = paging(ctx)
+    if (!page) return problemResponse(invalidSkipTake())
+    return Response.json({
+      total: OBJECT_TYPES.length,
+      items: OBJECT_TYPES.slice(page.skip, page.skip + page.take),
+    })
+  })
+  router.handle('GetHelp', (ctx) => {
+    const page = paging(ctx)
+    if (!page) return problemResponse(invalidSkipTake())
+    return Response.json({ total: 0, items: [] })
+  })
+}

package/src/handlers/relations.ts

@@ -0,0 +1,60 @@
+/**
+ * Relation types and their relations, read-only and derived (story 046), and
+ * the recycle bins' "what refers to what is in here" lists.
+ */
+import { invalidSkipTake, notFound, paged, parseSkipTake, problemResponse } from '@crombolo/core'
+import type { ReferencePort, RelationPort } from '../ports-content.ts'
+import type { ManagementApiRouter } from '../router.ts'
+
+const missing = () => problemResponse(notFound('The relation type could not be found'))
+
+export function registerRelationHandlers(router: ManagementApiRouter, port: RelationPort): void {
+  router.handle('GetRelationType', (ctx) => {
+    const page = parseSkipTake(ctx.url.searchParams)
+    if (!page.ok) return problemResponse(invalidSkipTake())
+    const types = port.types()
+    return Response.json(
+      paged(types.slice(page.value.skip, page.value.skip + page.value.take), types.length),
+    )
+  })
+
+  router.handle('GetRelationTypeById', (ctx) => {
+    const id = String(ctx.params.id).toLowerCase()
+    const type = port.types().find((t) => t.id === id)
+    return type ? Response.json(type) : missing()
+  })
+
+  router.handle('GetItemRelationType', (ctx) => {
+    const ids = new Set(ctx.url.searchParams.getAll('id').map((id) => id.toLowerCase()))
+    // Built in, so none of them can be deleted.
+    return Response.json(
+      port
+        .types()
+        .filter((t) => ids.has(t.id))
+        .map((t) => ({ id: t.id, name: t.name, isDeletable: false, flags: [] })),
+    )
+  })
+
+  router.handle('GetRelationByRelationTypeId', async (ctx) => {
+    const page = parseSkipTake(ctx.url.searchParams)
+    if (!page.ok) return problemResponse(invalidSkipTake())
+    const result = await port.relations(String(ctx.params.id), page.value)
+    return result ? Response.json(paged(result.items, result.total)) : missing()
+  })
+}
+
+export function registerRecycleBinReferenceHandlers(
+  router: ManagementApiRouter,
+  port: ReferencePort,
+): void {
+  const ask = port.recycleBinReferencedBy?.bind(port)
+  if (!ask) return
+  for (const area of ['Document', 'Media', 'Element'] as const)
+    router.handle(`GetRecycleBin${area}ReferencedBy`, async (ctx) => {
+      // Umbraco pages these 20 at a time, as it does every references list.
+      const page = parseSkipTake(ctx.url.searchParams, 20)
+      if (!page.ok) return problemResponse(invalidSkipTake())
+      const result = await ask(area, page.value)
+      return Response.json(paged(result.items, result.total))
+    })
+}

package/src/handlers/search-index.ts

@@ -0,0 +1,96 @@
+/**
+ * The Examine dashboard: the indexes, their health, rebuilding one, and searching
+ * one directly. An index with items still waiting reports itself rebuilding, which
+ * is what makes the dashboard poll until they are done. docs/search.md.
+ */
+import { invalidSkipTake, problemDetails, problemResponse } from '@crombolo/core'
+import type { SearchIndexInfo, SearchIndexPort } from '../ports.ts'
+import type { ManagementApiRouter } from '../router.ts'
+import { paging } from './content-type.ts'
+
+const waiting = (n: number) => `${n} ${n === 1 ? 'item is' : 'items are'} waiting to be indexed`
+
+function toIndexResponse(index: SearchIndexInfo) {
+  return {
+    name: index.name,
+    healthStatus:
+      index.pending > 0
+        ? { status: 'Rebuilding', message: waiting(index.pending) }
+        : { status: 'Healthy', message: null },
+    canRebuild: true,
+    searcherName: index.searcherName,
+    documentCount: index.documentCount,
+    fieldCount: index.fieldCount,
+    providerProperties: null,
+    uniqueKeyFieldName: '__Key',
+  }
+}
+
+const indexNotFound = (name: string) =>
+  problemResponse(
+    problemDetails({
+      title: 'Index Not Found',
+      detail: `No index found with name = ${name}`,
+      status: 400,
+    }),
+  )
+
+export function registerSearchIndexHandlers(
+  router: ManagementApiRouter,
+  port: SearchIndexPort,
+): void {
+  router.handle('GetIndexer', async (ctx) => {
+    const page = paging(ctx)
+    if (!page) return problemResponse(invalidSkipTake())
+    const indexes = await port.indexes()
+    return Response.json({
+      total: indexes.length,
+      items: indexes.slice(page.skip, page.skip + page.take).map(toIndexResponse),
+    })
+  })
+
+  router.handle('GetIndexerByIndexName', async ({ params }) => {
+    const name = params.indexName as string
+    const index = await port.index(name)
+    return index ? Response.json(toIndexResponse(index)) : indexNotFound(name)
+  })
+
+  router.handle('PostIndexerByIndexNameRebuild', async ({ params }) => {
+    const name = params.indexName as string
+    return (await port.rebuild(name)) ? new Response(null, { status: 200 }) : indexNotFound(name)
+  })
+
+  router.handle('GetSearcher', (ctx) => {
+    const page = paging(ctx)
+    if (!page) return problemResponse(invalidSkipTake())
+    const names = port.searchers()
+    return Response.json({
+      total: names.length,
+      items: names.slice(page.skip, page.skip + page.take).map((name) => ({ name })),
+    })
+  })
+
+  router.handle('GetSearcherBySearcherNameQuery', async (ctx) => {
+    const page = paging(ctx)
+    if (!page) return problemResponse(invalidSkipTake())
+    const name = ctx.params.searcherName as string
+    const result = await port.query(name, ctx.url.searchParams.get('term') ?? '', page)
+    if (!result)
+      return problemResponse(
+        problemDetails({
+          title: 'Searcher Not Found',
+          detail: `No searcher found with name = ${name}`,
+          status: 404,
+        }),
+      )
+    return Response.json({
+      total: result.total,
+      items: result.items.map((hit) => ({
+        id: hit.key,
+        score: hit.score,
+        fieldCount: hit.fields.length,
+        fields: hit.fields,
+      })),
+    })
+  })
+}

package/src/handlers/settings-stubs.ts

@@ -23,18 +23,9 @@ const PAGED = [
     `GetRecycleBin${b}Children`,
     `GetRecycleBin${b}ReferencedBy`,
   ]),
-  'GetRecycleBinDocumentReferencedBy', // needs relations, story 046
-  'GetRecycleBinMediaReferencedBy',
-  'GetRecycleBinElementReferencedBy',
-  // The recycle bin and the trash and delete dialogs; needs relations, story 046. Until
-  // then they cannot warn that other content links to what is being removed.
-  'GetTreeStaticFileRoot',
-  'GetTreeStaticFileChildren',
-  'GetRelationType',
-  'GetWebhook',
 ]
 /** Ancestor lookups: a bare array. */
-const ANCESTORS = [...STUB_TREES.map((t) => `GetTree${t}Ancestors`), 'GetTreeStaticFileAncestors']
+const ANCESTORS = STUB_TREES.map((t) => `GetTree${t}Ancestors`)
 /** Sibling windows: `{ totalBefore, totalAfter, items }`. */
 const SIBLINGS = [
   ...STUB_TREES.map((t) => `GetTree${t}Siblings`),

package/src/handlers/start-node-trees.ts

@@ -82,3 +82,29 @@ export async function visibleSiblings(
   const visible = await onTheWay(start, source, window.items)
   return { items: visible.items, totalBefore: 0, totalAfter: 0 }
 }
+
+/** How far a filtered search looks before paging: past it, an editor refines the query. */
+const SEARCH_WINDOW = 1_000
+
+/**
+ * A page of search results as a user may see them: under a start node, and
+ * passing `allowed` (Browse, for documents). Unrestricted access pages in the
+ * database; otherwise a window of the best matches is filtered, then paged.
+ */
+export async function visibleSearch(
+  start: StartNodes,
+  allowed: ((chain: readonly string[]) => boolean) | undefined,
+  search: (paging: SkipTake) => Promise<Page<DocumentTreeItem>>,
+  paging: SkipTake,
+): Promise<Page<DocumentTreeItem>> {
+  if (start.root && !allowed) return search(paging)
+  const window = await search({ skip: 0, take: SEARCH_WINDOW })
+  const visible = window.items.filter((item) => {
+    const chain = chainOf(item)
+    return hasPathAccess(start, chain, item.isTrashed) && (allowed?.(chain) ?? true)
+  })
+  return {
+    total: visible.length,
+    items: visible.slice(paging.skip, paging.skip + paging.take),
+  }
+}