@bilal-fazlani/mock-server 0.2.1 → 0.3.0

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

@@ -0,0 +1,153 @@
+export type DirectSelector =
+  | { source: 'body'; segments: Array<string | number> }
+  | { source: 'path'; name: string }
+  | { source: 'query'; name: string }
+
+export type ProfileKeySelector = {
+  source: 'profileKey'
+  namespace: string
+  keySelector: DirectSelector
+}
+
+export type Selector = DirectSelector | ProfileKeySelector
+
+export type BearerProfileIdSelector = {
+  source: 'bearer'
+  claim?: string
+}
+
+export type ProfileIdSelector = Selector | BearerProfileIdSelector
+
+export class SelectorParseError extends Error {}
+
+export interface RequestContext {
+  body: unknown
+  pathParams: Record<string, string>
+  query: URLSearchParams
+  headers: Record<string, string>
+}
+
+const NAME_RE = /^[a-zA-Z_][a-zA-Z0-9_-]*$/
+const PROFILE_KEY_NAMESPACE_RE = /^[a-z0-9][a-z0-9_-]*$/
+const BODY_TOKEN_RE = /\.([a-zA-Z_][a-zA-Z0-9_]*)|\[(\d+)\]/g
+const BEARER_TOKEN_RE = /^Bearer +([a-zA-Z0-9\-._~+/]+=*)$/i
+
+export function parseProfileIdSelector(raw: string): ProfileIdSelector {
+  if (raw === 'bearer') return { source: 'bearer' }
+  if (raw.startsWith('bearer:')) {
+    const claim = raw.slice('bearer:'.length)
+    if (!NAME_RE.test(claim)) {
+      throw new SelectorParseError(`invalid bearer claim selector: ${raw}`)
+    }
+    return { source: 'bearer', claim }
+  }
+  return parseSelector(raw)
+}
+
+export function parseSelector(raw: string): Selector {
+  if (raw.startsWith('profileKey:')) {
+    const rest = raw.slice('profileKey:'.length)
+    const sep = rest.indexOf(':')
+    if (sep <= 0) throw new SelectorParseError(`invalid profile key selector: ${raw}`)
+    const namespace = rest.slice(0, sep)
+    const nestedRaw = rest.slice(sep + 1)
+    if (!PROFILE_KEY_NAMESPACE_RE.test(namespace) || nestedRaw.length === 0) {
+      throw new SelectorParseError(`invalid profile key selector: ${raw}`)
+    }
+    const keySelector = parseSelector(nestedRaw)
+    if (keySelector.source === 'profileKey') {
+      throw new SelectorParseError(`invalid profile key selector: ${raw}`)
+    }
+    return { source: 'profileKey', namespace, keySelector }
+  }
+  if (raw.startsWith('path:')) {
+    const name = raw.slice('path:'.length)
+    if (!NAME_RE.test(name)) throw new SelectorParseError(`invalid path selector: ${raw}`)
+    return { source: 'path', name }
+  }
+  if (raw.startsWith('query:')) {
+    const name = raw.slice('query:'.length)
+    if (!NAME_RE.test(name)) throw new SelectorParseError(`invalid query selector: ${raw}`)
+    return { source: 'query', name }
+  }
+  if (raw.startsWith('$')) {
+    return { source: 'body', segments: parseBodyPath(raw) }
+  }
+  throw new SelectorParseError(
+    `selector must start with "$", "path:", or "query:": ${raw}`,
+  )
+}
+
+function parseBodyPath(raw: string): Array<string | number> {
+  const rest = raw.slice(1)
+  const segments: Array<string | number> = []
+  let consumed = 0
+  BODY_TOKEN_RE.lastIndex = 0
+  let m: RegExpExecArray | null
+  while ((m = BODY_TOKEN_RE.exec(rest)) !== null) {
+    if (m.index !== consumed) throw new SelectorParseError(`invalid body selector: ${raw}`)
+    segments.push(m[1] !== undefined ? m[1] : Number(m[2]))
+    consumed = BODY_TOKEN_RE.lastIndex
+  }
+  if (consumed !== rest.length || segments.length === 0) {
+    throw new SelectorParseError(`invalid body selector: ${raw}`)
+  }
+  return segments
+}
+
+export function extractValue(
+  selector: Selector,
+  ctx: RequestContext,
+): string | number | null {
+  if (selector.source === 'profileKey') return extractValue(selector.keySelector, ctx)
+  if (selector.source === 'path') return ctx.pathParams[selector.name] ?? null
+  if (selector.source === 'query') return ctx.query.get(selector.name)
+  let current: unknown = ctx.body
+  for (const seg of selector.segments) {
+    if (typeof seg === 'number') {
+      if (!Array.isArray(current)) return null
+      current = current[seg]
+    } else {
+      if (current === null || typeof current !== 'object' || Array.isArray(current)) return null
+      current = (current as Record<string, unknown>)[seg]
+    }
+  }
+  return typeof current === 'string' || typeof current === 'number' ? current : null
+}
+
+export function extractProfileIdValue(
+  selector: ProfileIdSelector,
+  ctx: RequestContext,
+): string | number | null {
+  if (selector.source !== 'bearer') return extractValue(selector, ctx)
+
+  const authorization = headerValue(ctx.headers, 'authorization')
+  const match = authorization?.trim().match(BEARER_TOKEN_RE)
+  const token = match?.[1]
+  if (!token) return null
+  if (!selector.claim) return token
+
+  return extractJwtClaim(token, selector.claim)
+}
+
+function headerValue(headers: Record<string, string>, name: string): string | null {
+  for (const [key, value] of Object.entries(headers)) {
+    if (key.toLowerCase() === name) return value
+  }
+  return null
+}
+
+// JWT claims are decoded only to select a mock profile. This is deliberately
+// not authentication: signatures, issuer, audience, and expiry are not verified.
+function extractJwtClaim(token: string, claim: string): string | number | null {
+  const parts = token.split('.')
+  if (parts.length !== 3 || parts[1].length === 0) return null
+  try {
+    const payload = JSON.parse(Buffer.from(parts[1], 'base64url').toString('utf8')) as unknown
+    if (payload === null || typeof payload !== 'object' || Array.isArray(payload)) return null
+    const value = (payload as Record<string, unknown>)[claim]
+    return typeof value === 'string' || typeof value === 'number' ? value : null
+  } catch {
+    return null
+  }
+}

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

@@ -0,0 +1,43 @@
+export interface ProfileKeyCaptureDef {
+  namespace: string
+  keySelector: string
+}
+
+export interface ScenarioMeta {
+  /** Friendly name shown for the scenario (a resolver's `description` export
+   * or a fixture's `description`, falling back to the slug). */
+  label: string
+  /** Optional secondary line shown under the label in the catalog detail view
+   * (a resolver's `summary` export or a fixture's `summary`); present only when
+   * the scenario declares a non-empty summary. */
+  summary?: string
+}
+
+export interface EndpointDef {
+  name: string
+  displayName: string
+  method: string
+  path: string
+  mockType?: 'global' | 'profiled'
+  profileIdSelector?: string
+  captureProfileKeys?: ProfileKeyCaptureDef[]
+  scenarios: Record<string, ScenarioMeta>
+  /**
+   * Slugs in `scenarios` backed by a `<slug>.ts` resolver instead of a
+   * `<slug>.json` fixture. Always present; empty when the endpoint has none.
+   */
+  resolverScenarios: string[]
+  /** Raw parsed _schema.json (OpenAPI 3.1 operation object), if present. */
+  schema?: Record<string, unknown>
+}
+
+export interface SystemDef {
+  name: string
+  slug: string
+  baseUrlEnv: string
+  endpoints: EndpointDef[]
+}
+
+export interface Catalog {
+  systems: SystemDef[]
+}

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

@@ -0,0 +1,290 @@
+import fs from 'node:fs'
+import { fixtureFilePath, type Fixture } from '../mock-engine/fixtures'
+import { listPlaceholders } from '../mock-engine/template'
+import {
+  parsePathTemplate,
+  PathTemplate,
+  PathTemplateError,
+  templatesOverlap,
+} from './path-template'
+import {
+  parseProfileIdSelector,
+  parseSelector,
+  SelectorParseError,
+  type DirectSelector,
+  type ProfileIdSelector,
+} from './selector'
+import { buildSchemaRegistry, schemaKey, type SchemaRegistry } from './schema'
+import type { Catalog } from './types'
+
+const DEFAULT_SCENARIO = 'default'
+const REAL_SCENARIO = 'real'
+const PROFILE_KEY_NAMESPACE_RE = /^[a-z0-9][a-z0-9_-]*$/
+
+export interface ValidationResult {
+  errors: string[]
+  fixtures: Map<string, Fixture>
+  schemas: SchemaRegistry
+}
+
+export function validateCatalog(catalog: Catalog, catalogDir: string): ValidationResult {
+  const errors: string[] = []
+  const fixtures = new Map<string, Fixture>()
+  const { schemas, errors: schemaErrors } = buildSchemaRegistry(catalog)
+  errors.push(...schemaErrors)
+  const parsed: Array<{ method: string; template: PathTemplate; label: string }> = []
+
+  for (const system of catalog.systems) {
+    for (const endpoint of system.endpoints) {
+      const label = `${system.name}/${endpoint.name}`
+
+      let template: PathTemplate | null = null
+      try {
+        template = parsePathTemplate(endpoint.path)
+        parsed.push({ method: endpoint.method.toUpperCase(), template, label })
+      } catch (err) {
+        if (err instanceof PathTemplateError) errors.push(`${label}: ${err.message}`)
+        else throw err
+      }
+      const declaredParams = new Set(
+        template?.segments.flatMap((s) => (s.type === 'param' ? [s.name] : [])) ?? [],
+      )
+      const mockType = endpoint.mockType ?? 'profiled'
+
+      if (mockType === 'global') {
+        if (endpoint.profileIdSelector !== undefined) {
+          errors.push(`${label}: global endpoint must not declare profileIdSelector`)
+        }
+        if ((endpoint.captureProfileKeys ?? []).length > 0) {
+          errors.push(`${label}: global endpoint must not declare captureProfileKeys`)
+        }
+      } else {
+        if (!endpoint.profileIdSelector) {
+          errors.push(`${label}: profiled endpoint requires profileIdSelector`)
+        } else {
+          try {
+            const selector = parseProfileIdSelector(endpoint.profileIdSelector)
+            validateSelectorPath(label, 'selector', selector, declaredParams, errors)
+            if (selector.source === 'profileKey') {
+              validateNamespace(label, selector.namespace, 'profileIdSelector namespace', errors)
+            }
+          } catch (err) {
+            if (err instanceof SelectorParseError) errors.push(`${label}: ${err.message}`)
+            else throw err
+          }
+        }
+
+        const captures = endpoint.captureProfileKeys ?? []
+        if (captures.length > 0) {
+          const profileSelector = endpoint.profileIdSelector
+            ? parseProfileIdSelectorForValidation(
+                endpoint.profileIdSelector,
+                label,
+                'profileIdSelector',
+                errors,
+              )
+            : null
+          if (profileSelector?.source === 'profileKey') {
+            errors.push(`${label}: captureProfileKeys require a direct profileIdSelector`)
+          }
+        }
+        captures.forEach((capture, index) => {
+          validateNamespace(label, capture.namespace, `captureProfileKeys[${index}].namespace`, errors)
+          const selector = parseSelectorForValidation(
+            capture.keySelector,
+            label,
+            `captureProfileKeys[${index}].keySelector`,
+            errors,
+          )
+          if (!selector) return
+          if (selector.source === 'profileKey') {
+            errors.push(`${label}: captureProfileKeys[${index}].keySelector must be a direct selector`)
+            return
+          }
+          validateSelectorPath(
+            label,
+            `captureProfileKeys[${index}].keySelector`,
+            selector,
+            declaredParams,
+            errors,
+          )
+        })
+      }
+
+      if (!(DEFAULT_SCENARIO in endpoint.scenarios)) {
+        errors.push(
+          `${label}: missing required "${DEFAULT_SCENARIO}" scenario ` +
+            `(no default.json or default.ts)`,
+        )
+      }
+      if (REAL_SCENARIO in endpoint.scenarios) {
+        errors.push(
+          `${label}: scenario "${REAL_SCENARIO}" must not exist (real.json or real.ts) — ` +
+            `passthrough is implicit`,
+        )
+      }
+      const fixtureBacked = Object.keys(endpoint.scenarios).filter(
+        (s) => !endpoint.resolverScenarios.includes(s),
+      )
+      if (Object.keys(endpoint.scenarios).length > 0 && fixtureBacked.length === 0) {
+        errors.push(
+          `${label}: every scenario is resolver-backed (.ts) — declare at least one ` +
+            `fixture-backed scenario for resolvers to return`,
+        )
+      }
+
+      for (const scenario of Object.keys(endpoint.scenarios)) {
+        if (scenario === REAL_SCENARIO) continue // already flagged above
+        if (endpoint.resolverScenarios.includes(scenario)) continue // backed by <slug>.ts, not a fixture
+        const file = fixtureFilePath(catalogDir, system.slug, endpoint.name, scenario)
+        if (!fs.existsSync(file)) {
+          errors.push(`${label}: missing fixture for scenario "${scenario}" (${file})`)
+          continue
+        }
+        let fixture: { status?: unknown; headers?: unknown; body?: unknown }
+        try {
+          fixture = JSON.parse(fs.readFileSync(file, 'utf8'))
+        } catch {
+          errors.push(`${label}: fixture ${file} is not valid JSON`)
+          continue
+        }
+        if (typeof fixture.status !== 'number' || !('body' in fixture)) {
+          errors.push(`${label}: fixture ${file} must have numeric "status" and a "body"`)
+          continue
+        }
+        fixtures.set(file, fixture as Fixture)
+        const compiled = schemas.get(schemaKey(system.slug, endpoint.name))
+        if (compiled) {
+          if (!compiled.hasResponseFor(fixture.status)) {
+            errors.push(
+              `${label}: fixture ${file} has status ${fixture.status} with no matching response ` +
+                `schema (declare "${fixture.status}", "${Math.floor(fixture.status / 100)}XX", ` +
+                `or "default" in _schema.json responses)`,
+            )
+          } else {
+            for (const issue of compiled.validateFixtureBody(fixture.status, fixture.body)) {
+              errors.push(
+                `${label}: fixture ${file} body does not match _schema.json: ${issue.path} ${issue.message}`,
+              )
+            }
+          }
+        }
+        const placeholders = [
+          ...listPlaceholders(fixture.body),
+          ...listPlaceholders(fixture.headers ?? {}),
+        ]
+        for (const expr of placeholders) {
+          if (expr === 'now:iso' || expr === 'now:YYYYMMDD') continue
+          try {
+            const sel = parseSelector(expr)
+            if (sel.source === 'path' && !declaredParams.has(sel.name)) {
+              errors.push(
+                `${label}: fixture ${file} placeholder "{{${expr}}}" references undeclared path param`,
+              )
+            }
+          } catch {
+            errors.push(`${label}: fixture ${file} has invalid placeholder "{{${expr}}}"`)
+          }
+        }
+      }
+    }
+  }
+
+  for (let i = 0; i < parsed.length; i++) {
+    for (let j = i + 1; j < parsed.length; j++) {
+      if (
+        parsed[i].method === parsed[j].method &&
+        templatesOverlap(parsed[i].template, parsed[j].template)
+      ) {
+        errors.push(
+          `ambiguous endpoints: ${parsed[i].label} and ${parsed[j].label} can match the same ${parsed[i].method} request`,
+        )
+      }
+    }
+  }
+
+  return { errors, fixtures, schemas }
+}
+
+function parseSelectorForValidation(
+  raw: string,
+  label: string,
+  field: string,
+  errors: string[],
+) {
+  try {
+    return parseSelector(raw)
+  } catch (err) {
+    if (err instanceof SelectorParseError) {
+      errors.push(`${label}: invalid ${field}: ${err.message}`)
+      return null
+    }
+    throw err
+  }
+}
+
+function parseProfileIdSelectorForValidation(
+  raw: string,
+  label: string,
+  field: string,
+  errors: string[],
+): ProfileIdSelector | null {
+  try {
+    return parseProfileIdSelector(raw)
+  } catch (err) {
+    if (err instanceof SelectorParseError) {
+      errors.push(`${label}: invalid ${field}: ${err.message}`)
+      return null
+    }
+    throw err
+  }
+}
+
+function validateNamespace(
+  label: string,
+  namespace: string,
+  field: string,
+  errors: string[],
+): void {
+  if (!PROFILE_KEY_NAMESPACE_RE.test(namespace)) {
+    errors.push(`${label}: ${field} "${namespace}" must match [a-z0-9][a-z0-9_-]*`)
+  }
+}
+
+function validateSelectorPath(
+  label: string,
+  field: string,
+  selector: DirectSelector | ProfileIdSelector,
+  declaredParams: Set<string>,
+  errors: string[],
+): void {
+  if (selector.source === 'bearer') return
+  const directSelector = selector.source === 'profileKey' ? selector.keySelector : selector
+  if (directSelector.source === 'path' && !declaredParams.has(directSelector.name)) {
+    errors.push(
+      `${label}: ${field} "path:${directSelector.name}" has no matching {${directSelector.name}} in path template`,
+    )
+  }
+}
+
+// App-wide config that only makes sense once the catalog is known. When
+// passthrough is the implicit default, every system must be able to proxy at
+// startup. Otherwise missing base URLs are reported only when a request or UI
+// selection actually chooses passthrough.
+export function validateAppConfig(
+  catalog: Catalog,
+  env: Record<string, string | undefined>,
+  passthroughAsDefault: boolean,
+): string[] {
+  const errors: string[] = []
+  if (passthroughAsDefault) {
+    for (const system of catalog.systems) {
+      if (!env[system.baseUrlEnv]) {
+        errors.push(
+          `system "${system.name}": PASSTHROUGH_AS_DEFAULT=true requires ${system.baseUrlEnv} to be set`,
+        )
+      }
+    }
+  }
+  return errors
+}

package/.next/standalone/src/lib/config.ts

@@ -0,0 +1,93 @@
+import path from 'node:path'
+
+export type UnmockedUsers = 'ERROR' | 'DEFAULT_MOCK' | 'REAL'
+export type ConsoleLogLevel = 'info' | 'warn' | 'error'
+
+// UI label for the implicit "real" scenario — never declared in the catalog,
+// so its display name lives here.
+export const REAL_LABEL = 'Passthrough'
+
+export class ConfigError extends Error {}
+
+const UNMOCKED_USERS_VALUES: UnmockedUsers[] = ['ERROR', 'DEFAULT_MOCK', 'REAL']
+const CONSOLE_LOG_LEVEL_VALUES: ConsoleLogLevel[] = ['info', 'warn', 'error']
+
+export function parsePassthroughAsDefault(raw: string | undefined): boolean {
+  if (raw === undefined) return false
+  const upper = raw.toUpperCase()
+  if (upper === 'TRUE') return true
+  if (upper === 'FALSE') return false
+  throw new ConfigError(
+    `PASSTHROUGH_AS_DEFAULT must be either true or false, got "${raw}"`,
+  )
+}
+
+export function parseUnmockedUsers(raw: string | undefined): UnmockedUsers {
+  if (raw === undefined) return 'ERROR'
+  const upper = raw.toUpperCase()
+  if (!UNMOCKED_USERS_VALUES.includes(upper as UnmockedUsers)) {
+    throw new ConfigError(
+      `UNMOCKED_USERS must be one of ${UNMOCKED_USERS_VALUES.join(', ')}, got "${raw}"`,
+    )
+  }
+  return upper as UnmockedUsers
+}
+
+export function parseConsoleLogLevel(raw: string | undefined): ConsoleLogLevel {
+  if (raw === undefined) return 'info'
+  const lower = raw.toLowerCase()
+  if (!CONSOLE_LOG_LEVEL_VALUES.includes(lower as ConsoleLogLevel)) {
+    throw new ConfigError(
+      `MOCK_CONSOLE_LOG_LEVEL must be one of ${CONSOLE_LOG_LEVEL_VALUES.join(', ')}, got "${raw}"`,
+    )
+  }
+  return lower as ConsoleLogLevel
+}
+
+export function parseResolverHistoryLimit(raw: string | undefined): number {
+  if (raw === undefined) return 10
+  const n = Number(raw)
+  if (!Number.isInteger(n) || n < 1) {
+    throw new ConfigError(`RESOLVER_HISTORY_LIMIT must be a positive integer, got "${raw}"`)
+  }
+  return n
+}
+
+const TTL_UNIT_SECONDS: Record<string, number> = { s: 1, m: 60, h: 3600, d: 86400 }
+
+// Parse REQUEST_LOG_TTL_DURATION into seconds for the requestLogs TTL index.
+// Format: <positive-integer><unit> where unit is s|m|h|d (e.g. "30m", "24h",
+// "7d"). Unset/empty defaults to one day (86400s), matching the pre-config
+// behavior. Anything else — missing unit, unsupported unit, zero, non-integer,
+// or compound like "1d12h" — is a startup-fatal ConfigError.
+export function parseRequestLogTtlSeconds(raw: string | undefined): number {
+  if (raw === undefined || raw === '') return 86400
+  const match = /^(\d+)(s|m|h|d)$/.exec(raw)
+  if (!match) {
+    throw new ConfigError(
+      `REQUEST_LOG_TTL_DURATION must be a positive duration like "24h", "30m", or "7d" (units s|m|h|d), got "${raw}"`,
+    )
+  }
+  const count = Number(match[1])
+  if (count < 1) {
+    throw new ConfigError(`REQUEST_LOG_TTL_DURATION must be greater than zero, got "${raw}"`)
+  }
+  return count * TTL_UNIT_SECONDS[match[2]]
+}
+
+// Resolve the catalog directory from CATALOG_PATH. A relative value is
+// resolved against the current working directory; an absolute value is used
+// as-is. Defaults to ./catalog. The npx launcher always passes an absolute
+// path here (its own cwd differs from the user's), so this stays cwd-agnostic.
+//
+// The catalog directory lives outside this project entirely (it's supplied
+// by the user at runtime), so its resolved path is never used to require or
+// bundle repo-internal modules. Without the turbopackIgnore hint, Next's
+// output-file-tracing sees a dynamic path.resolve() argument feeding into
+// later fs reads and — unable to prove it's confined to a safe subfolder —
+// falls back to sweeping the entire project into the standalone build
+// (leaking src/, tests/, docs/, etc.). See the "Encountered unexpected file
+// in NFT list" build warning this silences.
+export function resolveCatalogDir(raw: string | undefined): string {
+  return path.resolve(/*turbopackIgnore: true*/ raw ?? 'catalog')
+}

package/.next/standalone/src/lib/dynamic/history-store.ts

@@ -0,0 +1,68 @@
+import { Db } from 'mongodb'
+
+export type DynamicOwnerType = 'profile' | 'global'
+
+interface DynamicHistoryDoc {
+  ownerType: DynamicOwnerType
+  ownerKey: string
+  endpointName: string
+  /** The resolver-backed scenario slug this window belongs to. */
+  scenario: string
+  history: string[]
+  createdAt: Date
+  modifiedAt: Date
+}
+
+const COLLECTION = 'dynamicHistory'
+
+export async function getDynamicHistory(
+  db: Db,
+  ownerType: DynamicOwnerType,
+  ownerKey: string,
+  endpointName: string,
+  scenario: string,
+): Promise<string[]> {
+  const doc = await db
+    .collection<DynamicHistoryDoc>(COLLECTION)
+    .findOne({ ownerType, ownerKey, endpointName, scenario }, { projection: { _id: 0, history: 1 } })
+  return doc?.history ?? []
+}
+
+export async function appendDynamicHistory(
+  db: Db,
+  ownerType: DynamicOwnerType,
+  ownerKey: string,
+  endpointName: string,
+  scenario: string,
+  slug: string,
+  limit: number,
+): Promise<void> {
+  const now = new Date()
+  await db.collection<DynamicHistoryDoc>(COLLECTION).updateOne(
+    { ownerType, ownerKey, endpointName, scenario },
+    {
+      $push: { history: { $each: [slug], $slice: -Math.max(1, limit) } },
+      $set: { modifiedAt: now },
+      $setOnInsert: { ownerType, ownerKey, endpointName, scenario, createdAt: now },
+    },
+    { upsert: true },
+  )
+}
+
+// Reset clears every scenario's window for the owner (+endpoint): the UI
+// exposes one reset button per endpoint, and pre-rename rows (no `scenario`
+// field) simply never match get/append again — clean break, no migration.
+export async function resetDynamicHistory(
+  db: Db,
+  ownerType: DynamicOwnerType,
+  ownerKey: string,
+  endpointName?: string,
+): Promise<void> {
+  await db
+    .collection<DynamicHistoryDoc>(COLLECTION)
+    .deleteMany(
+      endpointName === undefined
+        ? { ownerType, ownerKey }
+        : { ownerType, ownerKey, endpointName },
+    )
+}