@bilal-fazlani/mock-server 0.2.1 → 0.3.0

package/.next/standalone/src/app/ui/logs/types.ts

@@ -0,0 +1,17 @@
+import type { LogEntry, LogSummary } from '../../../lib/logs/store'
+
+/** LogEntry as it crosses the server/client boundary: ts serialized to ISO. */
+export type LogEntryView = Omit<LogEntry, 'ts'> & { ts: string }
+
+export function toLogEntryView(entry: LogEntry): LogEntryView {
+  return { ...entry, ts: new Date(entry.ts).toISOString() }
+}
+
+/** Row-list shape: LogEntryView without the heavy request/response payloads. */
+export type LogSummaryView = Omit<LogEntryView, 'request' | 'response'> & {
+  response?: { status: number }
+}
+
+export function toLogSummaryView(entry: LogSummary): LogSummaryView {
+  return { ...entry, ts: new Date(entry.ts).toISOString() }
+}

package/.next/standalone/src/app/ui/profiles/actions.ts

@@ -0,0 +1,60 @@
+'use server'
+
+import { revalidatePath } from 'next/cache'
+import { redirect } from 'next/navigation'
+import { resetDynamicHistory } from '../../../lib/dynamic/history-store'
+import { writeAdminLog } from '../../../lib/logs/admin-log'
+import { parseEndpointScenarios } from '../../../lib/profiles/form'
+import {
+  deleteProfile,
+  getDb,
+  resetScenarioProgress,
+  upsertProfile,
+} from '../../../lib/profiles/store'
+import { getRuntime } from '../../../lib/runtime'
+import { implicitScenario } from '../../../lib/scenarios'
+
+export async function saveProfile(formData: FormData): Promise<void> {
+  const profileId = String(formData.get('profileId') ?? '').trim() || crypto.randomUUID()
+  const displayName = String(formData.get('displayName') ?? '').trim() || undefined
+
+  const { catalog, passthroughAsDefault } = getRuntime()
+  const implicit = implicitScenario(passthroughAsDefault)
+  const endpointScenarios = parseEndpointScenarios(formData, catalog, implicit)
+
+  await upsertProfile(await getDb(), { profileId, displayName, endpointScenarios })
+  await writeAdminLog(await getDb(), profileId, 'profile_saved')
+  redirect('/ui')
+}
+
+export async function deleteProfileAction(formData: FormData): Promise<void> {
+  const profileId = String(formData.get('profileId') ?? '').trim()
+  if (!profileId) throw new Error('profileId is required')
+
+  await deleteProfile(await getDb(), profileId)
+  redirect('/ui')
+}
+
+export async function resetScenarioProgressAction(
+  endpointName: string,
+  formData: FormData,
+): Promise<void> {
+  const profileId = String(formData.get('profileId') ?? '').trim()
+  if (!profileId || !endpointName) throw new Error('profileId and endpoint are required')
+
+  await resetScenarioProgress(await getDb(), profileId, endpointName)
+  await writeAdminLog(await getDb(), profileId, 'progress_reset', endpointName)
+  revalidatePath(`/ui/profiles/${encodeURIComponent(profileId)}`)
+}
+
+export async function resetDynamicHistoryAction(
+  endpointName: string,
+  formData: FormData,
+): Promise<void> {
+  const profileId = String(formData.get('profileId') ?? '').trim()
+  if (!profileId || !endpointName) throw new Error('profileId and endpoint are required')
+
+  await resetDynamicHistory(await getDb(), 'profile', profileId, endpointName)
+  await writeAdminLog(await getDb(), profileId, 'progress_reset', endpointName)
+  revalidatePath(`/ui/profiles/${encodeURIComponent(profileId)}`)
+}

package/.next/standalone/src/lib/build-info.ts

@@ -0,0 +1,13 @@
+// Build-time version and git SHA, injected as inlined public env vars by
+// next.config.ts. Import from here instead of reading process.env directly so
+// there is a single source of truth for what "this build" is.
+export const BUILD_INFO = {
+  version: process.env.NEXT_PUBLIC_APP_VERSION ?? '0.0.0-dev',
+  gitSha: process.env.NEXT_PUBLIC_GIT_SHA ?? 'unknown',
+} as const
+
+// Short SHA for compact display; leaves sentinel values ("unknown", "dev") intact.
+export const gitShaShort =
+  BUILD_INFO.gitSha.length >= 7 && /^[0-9a-f]+$/i.test(BUILD_INFO.gitSha)
+    ? BUILD_INFO.gitSha.slice(0, 7)
+    : BUILD_INFO.gitSha

package/.next/standalone/src/lib/catalog/find.ts

@@ -0,0 +1,17 @@
+import type { Catalog, EndpointDef, SystemDef } from './types'
+
+export type { Catalog } from './types'
+
+export function findEndpointBySlug(
+  catalog: Catalog,
+  slug: string,
+  endpointName: string,
+): { system: SystemDef; endpoint: EndpointDef } | null {
+  for (const system of catalog.systems) {
+    if (system.slug !== slug) continue
+    for (const endpoint of system.endpoints) {
+      if (endpoint.name === endpointName) return { system, endpoint }
+    }
+  }
+  return null
+}

package/.next/standalone/src/lib/catalog/load.ts

@@ -0,0 +1,226 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import type { Catalog, EndpointDef, ScenarioMeta, SystemDef } from './types'
+
+const SYSTEM_META = '_system.json'
+const ENDPOINT_META = '_endpoint.json'
+const SCHEMA_META = '_schema.json'
+const SCENARIO_FILE = /^([a-z0-9][a-z0-9_-]*)\.(json|ts)$/
+
+export class CatalogLoadError extends Error {}
+
+// Walks catalog/<system>/<endpoint>/<scenario>.json. Structural problems
+// (missing metadata, stray entries, bad scenario names) are fatal and
+// aggregated into one CatalogLoadError; fixture *content* problems are
+// left to validateCatalog so they land in the startup error list.
+export function loadCatalog(catalogDir: string): Catalog {
+  if (!fs.existsSync(catalogDir)) {
+    throw new CatalogLoadError(`catalog directory not found: ${catalogDir}`)
+  }
+  const problems: string[] = []
+  const systems: SystemDef[] = []
+
+  for (const sysEntry of sortedEntries(catalogDir)) {
+    if (!sysEntry.isDirectory()) {
+      problems.push(`unexpected entry in catalog root (systems are directories): ${sysEntry.name}`)
+      continue
+    }
+    const slug = sysEntry.name
+    const systemDir = path.join(catalogDir, slug)
+    const sysMeta = readMetaFile(path.join(systemDir, SYSTEM_META), problems)
+    if (!sysMeta) continue
+
+    const endpoints: EndpointDef[] = []
+    for (const epEntry of sortedEntries(systemDir)) {
+      if (epEntry.name === SYSTEM_META) continue
+      if (!epEntry.isDirectory()) {
+        problems.push(`${slug}: unexpected entry (endpoints are directories): ${epEntry.name}`)
+        continue
+      }
+      const endpointName = epEntry.name
+      const endpointDir = path.join(systemDir, endpointName)
+      const epMeta = readMetaFile(path.join(endpointDir, ENDPOINT_META), problems)
+      if (!epMeta) continue
+
+      const schemaFile = path.join(endpointDir, SCHEMA_META)
+      const schemaMeta = fs.existsSync(schemaFile) ? readMetaFile(schemaFile, problems) : null
+
+      const scenarios: Record<string, ScenarioMeta> = {}
+      const fixtureSlugs = new Set<string>()
+      const resolverSlugs = new Set<string>()
+      for (const fixEntry of sortedEntries(endpointDir)) {
+        if (fixEntry.name === ENDPOINT_META || fixEntry.name === SCHEMA_META) continue
+        const match = fixEntry.isFile() ? SCENARIO_FILE.exec(fixEntry.name) : null
+        if (!match) {
+          problems.push(
+            `${slug}/${endpointName}: unexpected entry (scenarios are <name>.json fixtures or ` +
+              `<name>.ts resolvers, name matching [a-z0-9][a-z0-9_-]*): ${fixEntry.name}`,
+          )
+          continue
+        }
+        const [, scenario, ext] = match
+        if (ext === 'ts') {
+          resolverSlugs.add(scenario)
+          // Label = slug for now; getRuntime patches in the compiled resolver's
+          // `description` and `summary` exports after compilation.
+          scenarios[scenario] ??= { label: scenario }
+        } else {
+          fixtureSlugs.add(scenario)
+          const meta = parseScenarioFile(path.join(endpointDir, fixEntry.name))
+          scenarios[scenario] = {
+            label: meta.description ?? scenario,
+            ...(meta.summary ? { summary: meta.summary } : {}),
+          }
+        }
+      }
+      for (const scenario of resolverSlugs) {
+        if (fixtureSlugs.has(scenario)) {
+          problems.push(
+            `${slug}/${endpointName}: scenario "${scenario}" is backed by both ` +
+              `${scenario}.json and ${scenario}.ts — pick one`,
+          )
+        }
+      }
+
+      const label = `${slug}/${endpointName}`
+      endpoints.push({
+        name: endpointName,
+        displayName: requireString(epMeta, 'displayName', label, problems),
+        method: requireString(epMeta, 'method', label, problems),
+        path: requireString(epMeta, 'path', label, problems),
+        ...optionalMockType(epMeta, label, problems),
+        ...optionalProfileIdSelector(epMeta),
+        ...optionalCaptureProfileKeys(epMeta, label, problems),
+        scenarios: orderDefaultFirst(scenarios),
+        resolverScenarios: [...resolverSlugs].sort(),
+        ...(schemaMeta ? { schema: schemaMeta } : {}),
+      })
+    }
+
+    systems.push({
+      name: requireString(sysMeta, 'name', slug, problems),
+      slug,
+      baseUrlEnv: requireString(sysMeta, 'baseUrlEnv', slug, problems),
+      endpoints,
+    })
+  }
+
+  if (problems.length > 0) {
+    throw new CatalogLoadError(`invalid catalog structure:\n - ${problems.join('\n - ')}`)
+  }
+  return { systems }
+}
+
+function optionalMockType(
+  meta: Record<string, unknown>,
+  label: string,
+  problems: string[],
+): Pick<EndpointDef, 'mockType'> | Record<string, never> {
+  const value = meta.mockType
+  if (value === undefined) return {}
+  if (value === 'global' || value === 'profiled') return { mockType: value }
+  problems.push(`${label}: "mockType" must be either "global" or "profiled"`)
+  return {}
+}
+
+function optionalProfileIdSelector(
+  meta: Record<string, unknown>,
+): Pick<EndpointDef, 'profileIdSelector'> | Record<string, never> {
+  const value = meta.profileIdSelector
+  return typeof value === 'string' && value.length > 0 ? { profileIdSelector: value } : {}
+}
+
+function sortedEntries(dir: string): fs.Dirent[] {
+  return fs
+    .readdirSync(dir, { withFileTypes: true })
+    .filter((e) => !e.name.startsWith('.'))
+    .sort((a, b) => a.name.localeCompare(b.name))
+}
+
+function readMetaFile(file: string, problems: string[]): Record<string, unknown> | null {
+  if (!fs.existsSync(file)) {
+    problems.push(`missing metadata file: ${file}`)
+    return null
+  }
+  try {
+    const parsed: unknown = JSON.parse(fs.readFileSync(file, 'utf8'))
+    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+      return parsed as Record<string, unknown>
+    }
+    problems.push(`metadata file must be a JSON object: ${file}`)
+  } catch {
+    problems.push(`metadata file is not valid JSON: ${file}`)
+  }
+  return null
+}
+
+function requireString(
+  meta: Record<string, unknown>,
+  field: string,
+  label: string,
+  problems: string[],
+): string {
+  const value = meta[field]
+  if (typeof value === 'string' && value.length > 0) return value
+  problems.push(`${label}: missing or invalid "${field}"`)
+  return ''
+}
+
+function optionalCaptureProfileKeys(
+  meta: Record<string, unknown>,
+  label: string,
+  problems: string[],
+): Pick<EndpointDef, 'captureProfileKeys'> | Record<string, never> {
+  const value = meta.captureProfileKeys
+  if (value === undefined) return {}
+  if (!Array.isArray(value)) {
+    problems.push(`${label}: "captureProfileKeys" must be an array`)
+    return {}
+  }
+  const captureProfileKeys: EndpointDef['captureProfileKeys'] = []
+  for (const [index, item] of value.entries()) {
+    if (item === null || typeof item !== 'object' || Array.isArray(item)) {
+      problems.push(`${label}: captureProfileKeys[${index}] must be an object`)
+      continue
+    }
+    const capture = item as Record<string, unknown>
+    const namespace = capture.namespace
+    const keySelector = capture.keySelector
+    if (typeof namespace !== 'string' || namespace.length === 0) {
+      problems.push(`${label}: captureProfileKeys[${index}].namespace must be a non-empty string`)
+    }
+    if (typeof keySelector !== 'string' || keySelector.length === 0) {
+      problems.push(`${label}: captureProfileKeys[${index}].keySelector must be a non-empty string`)
+    }
+    if (typeof namespace === 'string' && namespace.length > 0 && typeof keySelector === 'string' && keySelector.length > 0) {
+      captureProfileKeys.push({ namespace, keySelector })
+    }
+  }
+  return { captureProfileKeys }
+}
+
+// Lenient by design: an unreadable fixture falls back to the filename for the
+// label here and gets reported properly by validateCatalog.
+function parseScenarioFile(file: string): { description: string | null; summary: string | null } {
+  try {
+    const parsed: unknown = JSON.parse(fs.readFileSync(file, 'utf8'))
+    if (parsed && typeof parsed === 'object') {
+      const obj = parsed as { description?: unknown; summary?: unknown }
+      return {
+        description: typeof obj.description === 'string' ? obj.description : null,
+        summary: typeof obj.summary === 'string' && obj.summary.length > 0 ? obj.summary : null,
+      }
+    }
+  } catch {
+    // reported by validateCatalog
+  }
+  return { description: null, summary: null }
+}
+
+function orderDefaultFirst(
+  scenarios: Record<string, ScenarioMeta>,
+): Record<string, ScenarioMeta> {
+  if (!('default' in scenarios)) return scenarios
+  const { default: defaultMeta, ...rest } = scenarios
+  return { default: defaultMeta, ...rest }
+}

package/.next/standalone/src/lib/catalog/path-template.ts

@@ -0,0 +1,63 @@
+export type PathSegment =
+  | { type: 'literal'; value: string }
+  | { type: 'param'; name: string }
+
+export interface PathTemplate {
+  raw: string
+  segments: PathSegment[]
+}
+
+export class PathTemplateError extends Error {}
+
+const PARAM_RE = /^\{([a-zA-Z_][a-zA-Z0-9_]*)\}$/
+
+export function parsePathTemplate(raw: string): PathTemplate {
+  if (!raw.startsWith('/')) {
+    throw new PathTemplateError(`path template must start with "/": ${raw}`)
+  }
+  // A single trailing slash is cosmetic — matchPath already ignores it when
+  // matching requests, so normalize templates to match rather than reject.
+  const normalized = raw.length > 1 && raw.endsWith('/') ? raw.slice(0, -1) : raw
+  const segments: PathSegment[] = normalized
+    .slice(1)
+    .split('/')
+    .map((part) => {
+      const m = PARAM_RE.exec(part)
+      if (m) return { type: 'param' as const, name: m[1] }
+      if (part === '') throw new PathTemplateError(`empty segment in template: ${raw}`)
+      if (part.includes('{') || part.includes('}')) {
+        throw new PathTemplateError(`invalid segment "${part}" in template: ${raw}`)
+      }
+      return { type: 'literal' as const, value: part }
+    })
+  return { raw: normalized, segments }
+}
+
+export function matchPath(
+  template: PathTemplate,
+  requestPath: string,
+): Record<string, string> | null {
+  const parts = requestPath.split('/').filter((p) => p !== '')
+  if (parts.length !== template.segments.length) return null
+  const params: Record<string, string> = {}
+  for (let i = 0; i < parts.length; i++) {
+    const seg = template.segments[i]
+    if (seg.type === 'literal') {
+      if (seg.value !== parts[i]) return null
+    } else {
+      params[seg.name] = decodeURIComponent(parts[i])
+    }
+  }
+  return params
+}
+
+export function templatesOverlap(a: PathTemplate, b: PathTemplate): boolean {
+  if (a.segments.length !== b.segments.length) return false
+  return a.segments.every((seg, i) => {
+    const other = b.segments[i]
+    if (seg.type === 'literal' && other.type === 'literal') {
+      return seg.value === other.value
+    }
+    return true // a param position overlaps anything
+  })
+}

package/.next/standalone/src/lib/catalog/request-example.ts

@@ -0,0 +1,96 @@
+import {
+  parseProfileIdSelector,
+  parseSelector,
+  type DirectSelector,
+} from './selector'
+import type { EndpointDef } from './types'
+
+export interface EndpointRequestExample {
+  method: string
+  path: string
+  search: string
+  headers: Record<string, string>
+  body: Record<string, unknown> | null
+}
+
+/**
+ * Builds a skeleton request for an endpoint from what the catalog declares:
+ * path template params, the profile-ID selector, and capture key selectors.
+ * Values are `<name>` placeholders for the caller to fill in.
+ */
+export function buildEndpointRequestExample(endpoint: EndpointDef): EndpointRequestExample {
+  const selectors = collectSelectors(endpoint)
+  const body: Record<string, unknown> = {}
+  const query: string[] = []
+  const headers: Record<string, string> = {}
+
+  if (endpoint.profileIdSelector) {
+    try {
+      const profileSelector = parseProfileIdSelector(endpoint.profileIdSelector)
+      if (profileSelector.source === 'bearer') {
+        headers.authorization = profileSelector.claim
+          ? `Bearer <JWT with ${profileSelector.claim} claim>`
+          : 'Bearer <profileId>'
+      }
+    } catch {
+      // Invalid selectors are reported by catalog validation.
+    }
+  }
+
+  for (const selector of selectors) {
+    if (selector.source === 'body') {
+      setBodyPath(body, selector.segments)
+    } else if (selector.source === 'query') {
+      query.push(`${selector.name}=<${selector.name}>`)
+    }
+    // path selectors are covered by the path-template substitution below
+  }
+
+  return {
+    method: endpoint.method.toUpperCase(),
+    path: endpoint.path.replace(/\{([^}]+)\}/g, '<$1>'),
+    search: query.length > 0 ? `?${query.join('&')}` : '',
+    headers,
+    body: Object.keys(body).length > 0 ? body : null,
+  }
+}
+
+function collectSelectors(endpoint: EndpointDef): DirectSelector[] {
+  const selectors: DirectSelector[] = []
+
+  if (endpoint.profileIdSelector) {
+    try {
+      const parsed = parseProfileIdSelector(endpoint.profileIdSelector)
+      if (parsed.source !== 'bearer') {
+        selectors.push(parsed.source === 'profileKey' ? parsed.keySelector : parsed)
+      }
+    } catch {
+      // Invalid selectors are reported by catalog validation.
+    }
+  }
+
+  for (const capture of endpoint.captureProfileKeys ?? []) {
+    let parsed
+    try {
+      parsed = parseSelector(capture.keySelector)
+    } catch {
+      continue
+    }
+    selectors.push(parsed.source === 'profileKey' ? parsed.keySelector : parsed)
+  }
+  return selectors
+}
+
+function setBodyPath(target: Record<string, unknown>, segments: Array<string | number>): void {
+  let current = target
+  for (let i = 0; i < segments.length - 1; i++) {
+    const segment = String(segments[i])
+    const next = current[segment]
+    if (next === null || typeof next !== 'object') {
+      current[segment] = {}
+    }
+    current = current[segment] as Record<string, unknown>
+  }
+  const leaf = segments[segments.length - 1]
+  current[String(leaf)] = `<${String(leaf)}>`
+}

package/.next/standalone/src/lib/catalog/schema.ts

@@ -0,0 +1,154 @@
+import Ajv2020, { type ErrorObject, type ValidateFunction } from 'ajv/dist/2020'
+import addFormats from 'ajv-formats'
+import type { Catalog } from './types'
+
+export class SchemaCompileError extends Error {}
+
+export interface SchemaIssue {
+  path: string
+  message: string
+}
+
+export type SchemaRegistry = Map<string, CompiledEndpointSchema>
+
+export function schemaKey(systemSlug: string, endpointName: string): string {
+  return `${systemSlug}/${endpointName}`
+}
+
+const PLACEHOLDER_RE = /\{\{.+?\}\}/
+
+interface MediaTypeObject {
+  schema?: unknown
+}
+
+interface OperationObject {
+  requestBody?: { required?: boolean; content?: Record<string, MediaTypeObject> }
+  responses?: Record<string, { content?: Record<string, MediaTypeObject> }>
+}
+
+export interface CompiledEndpointSchema {
+  validateRequestBody(body: unknown): SchemaIssue[]
+  hasResponseFor(status: number): boolean
+  validateResponseBody(status: number, body: unknown): SchemaIssue[]
+  /** Like validateResponseBody, but placeholder-valued nodes are wildcards
+   *  and an unmatched status returns [] (reported separately at startup). */
+  validateFixtureBody(status: number, body: unknown): SchemaIssue[]
+}
+
+function jsonSchema(content: Record<string, MediaTypeObject> | undefined): unknown {
+  return content?.['application/json']?.schema
+}
+
+function toIssues(errors: ErrorObject[]): SchemaIssue[] {
+  return errors.map((e) => ({ path: e.instancePath || '/', message: e.message ?? 'invalid' }))
+}
+
+export function compileEndpointSchema(raw: unknown, label: string): CompiledEndpointSchema {
+  if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) {
+    throw new SchemaCompileError(
+      `${label}: _schema.json must be a JSON object (an OpenAPI 3.1 operation object)`,
+    )
+  }
+  const op = raw as OperationObject
+  const ajv = new Ajv2020({ strict: false, allErrors: true })
+  addFormats(ajv)
+
+  const compile = (schema: unknown, where: string): ValidateFunction => {
+    try {
+      return ajv.compile(schema as object)
+    } catch (err) {
+      throw new SchemaCompileError(
+        `${label}: invalid JSON Schema in ${where}: ${(err as Error).message}`,
+      )
+    }
+  }
+
+  const requestSchema = jsonSchema(op.requestBody?.content)
+  const validateRequest = requestSchema !== undefined ? compile(requestSchema, 'requestBody') : null
+  const requestRequired = op.requestBody?.required === true
+
+  const responses: Array<{ key: string; validate: ValidateFunction }> = []
+  for (const [key, res] of Object.entries(op.responses ?? {})) {
+    const schema = jsonSchema(res?.content)
+    if (schema !== undefined) responses.push({ key, validate: compile(schema, `responses.${key}`) })
+  }
+
+  const responseFor = (status: number): ValidateFunction | null => {
+    const exact = responses.find((r) => r.key === String(status))
+    if (exact) return exact.validate
+    const range = responses.find((r) => r.key.toUpperCase() === `${Math.floor(status / 100)}XX`)
+    if (range) return range.validate
+    return responses.find((r) => r.key === 'default')?.validate ?? null
+  }
+
+  return {
+    validateRequestBody(body: unknown): SchemaIssue[] {
+      if (!validateRequest) return []
+      if (body === null) {
+        return requestRequired ? [{ path: '/', message: 'request body is required' }] : []
+      }
+      validateRequest(body)
+      return toIssues(validateRequest.errors ?? [])
+    },
+    hasResponseFor(status: number): boolean {
+      return responseFor(status) !== null
+    },
+    validateResponseBody(status: number, body: unknown): SchemaIssue[] {
+      const validate = responseFor(status)
+      if (!validate) {
+        return [{ path: '/', message: `no response schema declared for status ${status}` }]
+      }
+      validate(body)
+      return toIssues(validate.errors ?? [])
+    },
+    validateFixtureBody(status: number, body: unknown): SchemaIssue[] {
+      const validate = responseFor(status)
+      if (!validate) return []
+      validate(body)
+      const errors = (validate.errors ?? []).filter(
+        (e) => !isPlaceholderValue(valueAtPointer(body, e.instancePath)),
+      )
+      return toIssues(errors)
+    },
+  }
+}
+
+function isPlaceholderValue(v: unknown): boolean {
+  return typeof v === 'string' && PLACEHOLDER_RE.test(v)
+}
+
+// Resolves an Ajv instancePath (RFC 6901 JSON pointer) against the document.
+function valueAtPointer(root: unknown, pointer: string): unknown {
+  if (pointer === '') return root
+  let cur: unknown = root
+  for (const seg of pointer.slice(1).split('/')) {
+    const key = seg.replace(/~1/g, '/').replace(/~0/g, '~')
+    if (Array.isArray(cur)) cur = cur[Number(key)]
+    else if (cur !== null && typeof cur === 'object') cur = (cur as Record<string, unknown>)[key]
+    else return undefined
+  }
+  return cur
+}
+
+export function buildSchemaRegistry(catalog: Catalog): {
+  schemas: SchemaRegistry
+  errors: string[]
+} {
+  const schemas: SchemaRegistry = new Map()
+  const errors: string[] = []
+  for (const system of catalog.systems) {
+    for (const endpoint of system.endpoints) {
+      if (endpoint.schema === undefined) continue
+      try {
+        schemas.set(
+          schemaKey(system.slug, endpoint.name),
+          compileEndpointSchema(endpoint.schema, `${system.name}/${endpoint.name}`),
+        )
+      } catch (err) {
+        if (err instanceof SchemaCompileError) errors.push(err.message)
+        else throw err
+      }
+    }
+  }
+  return { schemas, errors }
+}