@crombolo/api-management 0.0.0-stage → 0.9.1

package/src/handlers/server.ts

@@ -0,0 +1,25 @@
+/**
+ * The two endpoints the backoffice probes before anything else. If either fails
+ * the client hard-redirects to its error page, so they must be anonymous and
+ * must not depend on the database being reachable. Plus the upload settings
+ * the editor reads before it offers a file picker.
+ */
+import { DEFAULT_UPLOAD_SETTINGS } from '@crombolo/core'
+import type { ServerPort } from '../ports.ts'
+import type { ManagementApiRouter } from '../router.ts'
+
+export function registerServerHandlers(router: ManagementApiRouter, server: ServerPort): void {
+  router.handle('GetServerStatus', () => Response.json(server.status()))
+  router.handle('GetServerConfiguration', () => Response.json(server.configuration()))
+  router.handle('GetServerInformation', () => Response.json(server.information()))
+
+  router.handle('GetTemporaryFileConfiguration', () => {
+    const settings = server.uploadSettings?.() ?? DEFAULT_UPLOAD_SETTINGS
+    return Response.json({
+      imageFileTypes: settings.imageFileTypes,
+      disallowedUploadedFilesExtensions: settings.disallowedExtensions,
+      allowedUploadedFileExtensions: settings.allowedExtensions,
+      maxFileSize: settings.maxFileSize,
+    })
+  })
+}

package/src/handlers/settings-stubs.ts

@@ -0,0 +1,76 @@
+/**
+ * Trees and lists the backoffice renders for areas not yet built — in the
+ * Settings, Media and Library sections. Each answers an honest empty result in
+ * the shape its operation declares, so every section loads, expands and
+ * deep-links without an error toast; every one is replaced by a real handler
+ * when its work package lands (docs/07-roadmap.md, Phase 6). Counted
+ * separately by `coverage:api`.
+ */
+import { invalidSkipTake, notFound, problemResponse } from '@crombolo/core'
+import type { ManagementApiRouter } from '../router.ts'
+import { paging } from './content-type.ts'
+
+/** Trees with root, children, ancestors and siblings. */
+const STUB_TREES = [] as const
+/** Recycle bins for areas that have nothing to trash yet. */
+const STUB_BINS = [] as const
+
+/** Paged lists: `{ total, items }`, honouring skip/take validation. */
+const PAGED = [
+  ...STUB_TREES.flatMap((t) => [`GetTree${t}Root`, `GetTree${t}Children`]),
+  ...STUB_BINS.flatMap((b) => [
+    `GetRecycleBin${b}Root`,
+    `GetRecycleBin${b}Children`,
+    `GetRecycleBin${b}ReferencedBy`,
+  ]),
+  'GetRecycleBinDocumentReferencedBy', // needs relations, WP-6.9
+  'GetRecycleBinMediaReferencedBy',
+  'GetRecycleBinElementReferencedBy',
+  // The recycle bin and the trash and delete dialogs; needs relations, WP-6.9. 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']
+/** Sibling windows: `{ totalBefore, totalAfter, items }`. */
+const SIBLINGS = [
+  ...STUB_TREES.map((t) => `GetTree${t}Siblings`),
+  ...STUB_BINS.map((b) => `GetRecycleBin${b}Siblings`),
+]
+/** Lookups of one thing in an empty area: there is nothing to find. */
+const NOT_FOUND: string[] = []
+
+/** Fixed bodies. Umbraco's news dashboard relays umbraco.com; there is no feed to relay here. */
+const FIXED: Record<string, unknown> = {
+  GetNewsDashboard: { items: [] },
+}
+
+export const EMPTY_SETTINGS_OPERATIONS: readonly string[] = [
+  ...PAGED,
+  ...ANCESTORS,
+  ...SIBLINGS,
+  ...NOT_FOUND,
+  ...Object.keys(FIXED),
+]
+
+export function registerSettingsStubHandlers(router: ManagementApiRouter): void {
+  for (const operation of PAGED) {
+    router.handle(operation, (ctx) => {
+      if (!paging(ctx)) return problemResponse(invalidSkipTake())
+      return Response.json({ total: 0, items: [] })
+    })
+  }
+  for (const operation of ANCESTORS) router.handle(operation, () => Response.json([]))
+  for (const operation of SIBLINGS) {
+    router.handle(operation, () => Response.json({ totalBefore: 0, totalAfter: 0, items: [] }))
+  }
+  for (const operation of NOT_FOUND) {
+    router.handle(operation, () => problemResponse(notFound('The item could not be found')))
+  }
+  for (const [operation, body] of Object.entries(FIXED)) {
+    router.handle(operation, () => Response.json(body))
+  }
+}

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

@@ -0,0 +1,84 @@
+/**
+ * Trees as a user with start nodes sees them, as Umbraco's
+ * `UserStartNodeTreeControllerBase` serves them: at the root, their start
+ * nodes and the top-level ancestors of deeper ones; below a place they cannot
+ * reach, only the way down to a start node. Nodes on that way are shown with
+ * `noAccess`. With root access nothing is filtered.
+ */
+import { type DocumentTreeItem, hasPathAccess, type Page, type StartNodes } from '@crombolo/core'
+import type { SkipTake } from '../ports-content.ts'
+
+export interface TreeSource {
+  treeRoot(paging: SkipTake): Promise<Page<DocumentTreeItem>>
+  treeChildren(parentKey: string, paging: SkipTake): Promise<Page<DocumentTreeItem>>
+  items(keys: readonly string[]): Promise<DocumentTreeItem[]>
+}
+
+export interface VisibleItem {
+  item: DocumentTreeItem
+  noAccess: boolean
+}
+
+const EVERYTHING: SkipTake = { skip: 0, take: 1_000_000 }
+const chainOf = (item: DocumentTreeItem) => [...item.ancestorKeys, item.key]
+
+async function startChains(start: StartNodes, source: TreeSource): Promise<string[][]> {
+  return (await source.items(start.keys)).filter((i) => !i.isTrashed).map(chainOf)
+}
+
+/** Only what lies on the way to a start node; skip and take no longer apply. */
+async function onTheWay(
+  start: StartNodes,
+  source: TreeSource,
+  items: readonly DocumentTreeItem[],
+): Promise<Page<VisibleItem>> {
+  const chains = await startChains(start, source)
+  const visible = items
+    .filter((item) => chains.some((chain) => chain.includes(item.key)))
+    .map((item) => ({ item, noAccess: !start.keys.includes(item.key) }))
+  return { total: visible.length, items: visible }
+}
+
+const all = (page: Page<DocumentTreeItem>): Page<VisibleItem> => ({
+  total: page.total,
+  items: page.items.map((item) => ({ item, noAccess: false })),
+})
+
+export async function visibleRoot(
+  start: StartNodes,
+  source: TreeSource,
+  paging: SkipTake,
+): Promise<Page<VisibleItem>> {
+  if (start.root) return all(await source.treeRoot(paging))
+  return onTheWay(start, source, (await source.treeRoot(EVERYTHING)).items)
+}
+
+export async function visibleChildren(
+  start: StartNodes,
+  source: TreeSource,
+  parentKey: string,
+  paging: SkipTake,
+): Promise<Page<VisibleItem>> {
+  if (start.root) return all(await source.treeChildren(parentKey, paging))
+  const [parent] = await source.items([parentKey])
+  if (parent && hasPathAccess(start, chainOf(parent), parent.isTrashed))
+    return all(await source.treeChildren(parentKey, paging))
+  return onTheWay(start, source, (await source.treeChildren(parentKey, EVERYTHING)).items)
+}
+
+/** A siblings window, cut down to the way to a start node when the parent is out of reach. */
+export async function visibleSiblings(
+  start: StartNodes,
+  source: TreeSource,
+  window: { items: DocumentTreeItem[]; totalBefore: number; totalAfter: number },
+): Promise<{ items: VisibleItem[]; totalBefore: number; totalAfter: number }> {
+  const whole = { ...window, items: window.items.map((item) => ({ item, noAccess: false })) }
+  if (start.root) return whole
+  const parentKey = window.items[0]?.parentKey
+  if (parentKey) {
+    const [parent] = await source.items([parentKey])
+    if (parent && hasPathAccess(start, chainOf(parent), parent.isTrashed)) return whole
+  }
+  const visible = await onTheWay(start, source, window.items)
+  return { items: visible.items, totalBefore: 0, totalAfter: 0 }
+}

package/src/handlers/template-query.ts

@@ -0,0 +1,191 @@
+/**
+ * The template editor's query builder.
+ *
+ * It writes the snippet a component uses to pick content, so what it emits is
+ * **TypeScript against the render model** — `nav.children(...)` and the
+ * accessors a `.tsx` already has — rather than the Razor and LINQ Umbraco's own
+ * builder writes. The wire contract is still Umbraco's, so the field names here
+ * are theirs and only the expression inside is ours.
+ *
+ * `execute` runs the query it describes, so the count and the sample are the
+ * answer the snippet would give rather than a guess about it.
+ */
+import type { ResponseOf } from '@crombolo/contracts'
+import type {
+  TemplateQueryFilter,
+  TemplateQueryPort,
+  TemplateQueryRequest,
+  TemplateQuerySort,
+} from '../ports-content.ts'
+import type { ManagementApiRouter } from '../router.ts'
+
+/** What the builder can filter and sort on: the model's own fields. */
+const PROPERTIES = [
+  { alias: 'Id', type: 'Integer' },
+  { alias: 'Name', type: 'String' },
+  { alias: 'CreateDate', type: 'DateTime' },
+  { alias: 'UpdateDate', type: 'DateTime' },
+] as const
+
+const OPERATORS = [
+  { operator: 'Equals', applicableTypes: ['String', 'DateTime', 'Integer'] },
+  { operator: 'NotEquals', applicableTypes: ['String', 'DateTime', 'Integer'] },
+  { operator: 'Contains', applicableTypes: ['String'] },
+  { operator: 'NotContains', applicableTypes: ['String'] },
+  { operator: 'LessThan', applicableTypes: ['DateTime', 'Integer'] },
+  { operator: 'LessThanEqualTo', applicableTypes: ['DateTime', 'Integer'] },
+  { operator: 'GreaterThan', applicableTypes: ['DateTime', 'Integer'] },
+  { operator: 'GreaterThanEqualTo', applicableTypes: ['DateTime', 'Integer'] },
+] as const
+
+const TYPE_OF = new Map<string, string>(PROPERTIES.map((p) => [p.alias, p.type]))
+
+/** The accessor on a `PublishedContent` that each property names. */
+const ACCESSOR: Record<string, string> = {
+  Id: 'id',
+  Name: 'name',
+  CreateDate: 'createDate',
+  UpdateDate: 'updateDate',
+}
+
+const quote = (value: string) => `'${value.replaceAll('\\', '\\\\').replaceAll("'", "\\'")}'`
+
+/** A filter as a TypeScript predicate over `item`. */
+function predicate(filter: TemplateQueryFilter): string | undefined {
+  const accessor = ACCESSOR[filter.propertyAlias]
+  const type = TYPE_OF.get(filter.propertyAlias)
+  if (!accessor || !type) return undefined
+  const left = `item.${accessor}`
+  const value = filter.constraintValue
+
+  if (type === 'String') {
+    const right = quote(value)
+    switch (filter.operator) {
+      case 'Equals':
+        return `${left} === ${right}`
+      case 'NotEquals':
+        return `${left} !== ${right}`
+      case 'Contains':
+        return `${left}.includes(${right})`
+      case 'NotContains':
+        return `!${left}.includes(${right})`
+      default:
+        return undefined
+    }
+  }
+
+  // A date compares as a number, which is also what `Integer` already is.
+  const left_ = type === 'DateTime' ? `${left}.getTime()` : left
+  const right_ =
+    type === 'DateTime' ? `new Date(${quote(value)}).getTime()` : String(Number(value) || 0)
+  switch (filter.operator) {
+    case 'Equals':
+      return `${left_} === ${right_}`
+    case 'NotEquals':
+      return `${left_} !== ${right_}`
+    case 'LessThan':
+      return `${left_} < ${right_}`
+    case 'LessThanEqualTo':
+      return `${left_} <= ${right_}`
+    case 'GreaterThan':
+      return `${left_} > ${right_}`
+    case 'GreaterThanEqualTo':
+      return `${left_} >= ${right_}`
+    default:
+      return undefined
+  }
+}
+
+/** A sort as the comparator `Array.prototype.sort` takes. */
+function comparator(sort: TemplateQuerySort): string | undefined {
+  const accessor = ACCESSOR[sort.propertyAlias]
+  const type = TYPE_OF.get(sort.propertyAlias)
+  if (!accessor || !type) return undefined
+  const [first, second] = sort.direction?.toLowerCase() === 'descending' ? ['b', 'a'] : ['a', 'b']
+  if (type === 'String') return `${first}.${accessor}.localeCompare(${second}.${accessor})`
+  if (type === 'DateTime') return `${first}.${accessor}.getTime() - ${second}.${accessor}.getTime()`
+  return `${first}.${accessor} - ${second}.${accessor}`
+}
+
+/**
+ * The snippet itself.
+ *
+ * `?? model` rather than a guard on the lookup: a key that no longer resolves
+ * falls back to the page being rendered, so the component still compiles and
+ * still renders something.
+ */
+export function queryExpression(request: TemplateQueryRequest): string {
+  const from = request.rootKey
+    ? `nav.children(nav.byKey(${quote(request.rootKey)}) ?? model)`
+    : 'nav.children(model)'
+  const lines = [`const selection = ${from}`]
+  if (request.documentTypeAlias)
+    lines.push(
+      `  .filter((item) => item.contentType.alias === ${quote(request.documentTypeAlias)})`,
+    )
+  for (const filter of request.filters) {
+    const expression = predicate(filter)
+    if (expression) lines.push(`  .filter((item) => ${expression})`)
+  }
+  const sort = request.sort ? comparator(request.sort) : undefined
+  if (sort) lines.push(`  .sort((a, b) => ${sort})`)
+  lines.push(`  .slice(0, ${request.take})`)
+  return lines.join('\n')
+}
+
+export function registerTemplateQueryHandlers(
+  router: ManagementApiRouter,
+  port: TemplateQueryPort,
+): void {
+  router.handle('GetTemplateQuerySettings', async () => {
+    const documentTypeAliases = await port.documentTypeAliases()
+    return Response.json({
+      documentTypeAliases,
+      properties: PROPERTIES.map((property) => ({ ...property })),
+      operators: OPERATORS.map((operator) => ({
+        operator: operator.operator,
+        applicableTypes: [...operator.applicableTypes],
+      })),
+    } as ResponseOf<'GetTemplateQuerySettings'>)
+  })
+
+  router.handle('PostTemplateQueryExecute', async (ctx) => {
+    const body = (await ctx.request.json()) as Record<string, unknown>
+    const root = body.rootDocument as { id?: unknown } | null | undefined
+    const request: TemplateQueryRequest = {
+      rootKey: typeof root?.id === 'string' ? root.id : null,
+      documentTypeAlias:
+        typeof body.documentTypeAlias === 'string' && body.documentTypeAlias
+          ? body.documentTypeAlias
+          : null,
+      filters: (Array.isArray(body.filters) ? body.filters : [])
+        .map((filter) => filter as Record<string, unknown>)
+        .filter((filter) => typeof filter.propertyAlias === 'string' && filter.propertyAlias)
+        .map((filter) => ({
+          propertyAlias: String(filter.propertyAlias),
+          constraintValue: String(filter.constraintValue ?? ''),
+          operator: String(filter.operator ?? 'Equals'),
+        })),
+      sort:
+        body.sort && typeof (body.sort as Record<string, unknown>).propertyAlias === 'string'
+          ? {
+              propertyAlias: String((body.sort as Record<string, unknown>).propertyAlias),
+              direction: ((body.sort as Record<string, unknown>).direction as string) ?? null,
+            }
+          : null,
+      take: Number(body.take) > 0 ? Number(body.take) : 10,
+    }
+
+    const started = Bun.nanoseconds()
+    const result = await port.execute(request)
+    // Milliseconds, as the contract's `int64` and the client's label expect.
+    const executionTime = Math.round((Bun.nanoseconds() - started) / 1_000_000)
+
+    return Response.json({
+      queryExpression: queryExpression(request),
+      sampleResults: result.items.map((item) => ({ icon: item.icon, name: item.name })),
+      resultCount: result.total,
+      executionTime,
+    } as ResponseOf<'PostTemplateQueryExecute'>)
+  })
+}

package/src/handlers/template.ts

@@ -0,0 +1,150 @@
+/**
+ * Templates. The record holds the alias; the view file on disk holds the markup,
+ * and the editor reads and writes it through `content`.
+ */
+import type { ResponseOf } from '@crombolo/contracts'
+import type { ComponentModel } from '@crombolo/core'
+import { invalidSkipTake, notFound, problemDetails, problemResponse } from '@crombolo/core'
+import type { TemplatePort } from '../ports-content.ts'
+import type { ManagementApiRouter } from '../router.ts'
+import { created, paging, toTreeItemResponse } from './content-type.ts'
+
+function toResponse(model: ComponentModel): ResponseOf<'GetTemplateById'> {
+  return {
+    id: model.key,
+    name: model.name,
+    alias: model.alias,
+    content: model.content,
+    // The contract keeps the older name beside the one the client reads
+    layoutTemplate: model.masterKey ? { id: model.masterKey } : null,
+    masterTemplate: model.masterKey ? { id: model.masterKey } : null,
+  } as ResponseOf<'GetTemplateById'>
+}
+
+export function registerTemplateHandlers(router: ManagementApiRouter, port: TemplatePort): void {
+  router.handle('GetTemplateById', async ({ params }) => {
+    const model = await port.byKey(params.id as string)
+    if (!model) return problemResponse(notFound('The template could not be found'))
+    return Response.json(toResponse(model))
+  })
+
+  router.handle('PostTemplate', async (ctx) => {
+    const body = (await ctx.request.json()) as Record<string, unknown>
+    const key = typeof body.id === 'string' && body.id ? body.id : crypto.randomUUID()
+    const name = String(body.name ?? '')
+    const alias = String(body.alias ?? name)
+    await port.save(
+      {
+        key,
+        name,
+        alias,
+        content: typeof body.content === 'string' ? body.content : port.scaffold(name, alias),
+      },
+      ctx.principal as NonNullable<typeof ctx.principal>,
+    )
+    ctx.notifications.push({ message: 'Template created', category: 'Template', type: 'Success' })
+    return created(`${ctx.url.origin}/umbraco/management/api/v1/template/${key}`, key)
+  })
+
+  router.handle('PutTemplateById', async (ctx) => {
+    const key = ctx.params.id as string
+    const existing = await port.byKey(key)
+    if (!existing) return problemResponse(notFound('The template could not be found'))
+    const body = (await ctx.request.json()) as Record<string, unknown>
+    await port.save(
+      {
+        key,
+        name: String(body.name ?? existing.name),
+        alias: String(body.alias ?? existing.alias),
+        content: typeof body.content === 'string' ? body.content : existing.content,
+      },
+      ctx.principal as NonNullable<typeof ctx.principal>,
+    )
+    ctx.notifications.push({ message: 'Template saved', category: 'Template', type: 'Success' })
+    return new Response(null, { status: 200 })
+  })
+
+  router.handle('DeleteTemplateById', async (ctx) => {
+    const removed = await port.remove(ctx.params.id as string)
+    if (!removed) return problemResponse(notFound('The template could not be found'))
+    return new Response(null, { status: 200 })
+  })
+
+  router.handle('GetTreeTemplateRoot', async (ctx) => {
+    const page = paging(ctx)
+    if (!page) return problemResponse(invalidSkipTake())
+    const result = await port.root(page)
+    return Response.json({ total: result.total, items: result.items.map(toTreeItemResponse) })
+  })
+
+  router.handle('GetTreeTemplateChildren', async (ctx) => {
+    const page = paging(ctx)
+    if (!page) return problemResponse(invalidSkipTake())
+    const parentId = ctx.url.searchParams.get('parentId')
+    if (!parentId)
+      return problemResponse(problemDetails({ title: 'parentId is required', status: 400 }))
+    const result = await port.children(parentId, page)
+    return Response.json({ total: result.total, items: result.items.map(toTreeItemResponse) })
+  })
+
+  router.handle('GetTreeTemplateAncestors', async (ctx) => {
+    const descendantId = ctx.url.searchParams.get('descendantId')
+    // Umbraco binds a missing id to an empty GUID and answers with no ancestors.
+    if (!descendantId) return Response.json([])
+    return Response.json((await port.ancestors(descendantId)).map(toTreeItemResponse))
+  })
+
+  /** A template's ancestors are its layout chain, outermost first. */
+  router.handle('GetItemTemplateAncestors', async (ctx) => {
+    const result = []
+    for (const id of ctx.url.searchParams.getAll('id')) {
+      const ancestors = []
+      for (const item of await port.ancestors(id)) {
+        const model = await port.byKey(item.key)
+        ancestors.push({ id: item.key, name: item.name, alias: model?.alias ?? '', flags: [] })
+      }
+      result.push({ id, ancestors })
+    }
+    return Response.json(result)
+  })
+
+  router.handle('GetTreeTemplateSiblings', async (ctx) => {
+    const target = ctx.url.searchParams.get('target')
+    if (!target)
+      return problemResponse(problemDetails({ title: 'target is required', status: 400 }))
+    const window = await port.siblings(
+      target,
+      Number(ctx.url.searchParams.get('before') ?? 0),
+      Number(ctx.url.searchParams.get('after') ?? 0),
+    )
+    if (!window) return problemResponse(notFound('The template could not be found'))
+    return Response.json({ ...window, items: window.items.map(toTreeItemResponse) })
+  })
+
+  router.handle('GetItemTemplateSearch', async (ctx) => {
+    const page = paging(ctx)
+    if (!page) return problemResponse(invalidSkipTake())
+    const result = await port.search(ctx.url.searchParams.get('query') ?? '', page)
+    return Response.json({
+      total: result.total,
+      items: result.items.map((t) => ({ id: t.key, name: t.name, alias: t.alias, flags: [] })),
+    })
+  })
+
+  router.handle('GetItemTemplate', async (ctx) => {
+    const keys = ctx.url.searchParams.getAll('id')
+    const items = await port.items(keys)
+    // The template editor writes the master template's alias into the view
+    const aliases = await Promise.all(
+      items.map(async (item) => (await port.byKey(item.key))?.alias),
+    )
+    return Response.json(
+      items.map((item, i) => ({
+        id: item.key,
+        name: item.name,
+        alias: aliases[i] ?? null,
+        flags: [],
+      })),
+    )
+  })
+}

package/src/handlers/temporary-file.ts

@@ -0,0 +1,62 @@
+/**
+ * Temporary files: what an upload editor or the media dropzone posts before the
+ * value that uses it is saved.
+ */
+import { notFound, problemDetails, problemResponse } from '@crombolo/core'
+import type { TemporaryFilePort } from '../ports.ts'
+import type { ManagementApiRouter } from '../router.ts'
+import { created } from './content-type.ts'
+
+const toResponse = (file: { id: string; fileName: string; availableUntil: Date }) => ({
+  id: file.id,
+  fileName: file.fileName,
+  availableUntil: file.availableUntil.toISOString(),
+})
+
+export function registerTemporaryFileHandlers(
+  router: ManagementApiRouter,
+  port: TemporaryFilePort,
+): void {
+  router.handle('PostTemporaryFile', async (ctx) => {
+    let form: FormData
+    try {
+      form = await ctx.request.formData()
+    } catch {
+      return problemResponse(
+        problemDetails({ title: 'The upload must be multipart/form-data', status: 400 }),
+      )
+    }
+    const file = form.get('File')
+    const id = String(form.get('Id') ?? '') || crypto.randomUUID()
+    if (!(file instanceof File))
+      return problemResponse(problemDetails({ title: 'No file was uploaded', status: 400 }))
+    if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(id))
+      return problemResponse(problemDetails({ title: 'The id must be a uuid', status: 400 }))
+    const result = await port.save(id, file)
+    if (!result.ok)
+      return problemResponse(
+        problemDetails({
+          title: 'File upload failed',
+          detail: result.reason,
+          status: 400,
+          operationStatus: 'FileExtensionNotAllowed',
+        }),
+      )
+    return created(
+      `${ctx.url.origin}/umbraco/management/api/v1/temporary-file/${result.file.id}`,
+      result.file.id,
+    )
+  })
+
+  router.handle('GetTemporaryFileById', async ({ params }) => {
+    const file = await port.get(params.id as string)
+    if (!file) return problemResponse(notFound('The temporary file could not be found'))
+    return Response.json(toResponse(file))
+  })
+
+  router.handle('DeleteTemporaryFileById', async ({ params }) => {
+    const removed = await port.remove(params.id as string)
+    if (!removed) return problemResponse(notFound('The temporary file could not be found'))
+    return new Response(null, { status: 200 })
+  })
+}