velocious 1.0.430 → 1.0.432

package/src/frontend-models/use-updated-event.js

@@ -0,0 +1,152 @@
+// @ts-check
+
+import debounceFunction from "debounce"
+import {useEffect, useMemo, useRef} from "react"
+
+import clearPendingDebouncedCallback from "./clear-pending-debounced-callback.js"
+import {modelsDependencyKey, modelsFromInput} from "./event-hook-models.js"
+import useModelClassEvent from "./use-model-class-event.js"
+
+/**
+ * FrontendModelClass type.
+  @typedef {typeof import("./base.js").default} FrontendModelClass */
+/**
+ * FrontendModelInstance type.
+  @typedef {import("./base.js").default} FrontendModelInstance */
+/**
+ * FrontendModelClassUpdateEventPayload type.
+  @typedef {import("./use-model-class-event.js").FrontendModelCreateUpdateEventPayload} FrontendModelClassUpdateEventPayload */
+/**
+ * Defines this typedef.
+  @typedef {{id: string, model: FrontendModelInstance}} FrontendModelInstanceUpdateEventPayload */
+/**
+ * FrontendModelUpdateEventPayload type.
+  @typedef {FrontendModelClassUpdateEventPayload | FrontendModelInstanceUpdateEventPayload} FrontendModelUpdateEventPayload */
+/**
+ * UseUpdatedEventOptions type.
+  @typedef {import("./use-model-class-event.js").UseModelClassEventOptions} UseUpdatedEventOptions */
+/**
+ * FrontendModelUpdateEventCallback type.
+  @typedef {(payload: FrontendModelUpdateEventPayload) => void} FrontendModelUpdateEventCallback */
+
+/**
+ * Runs assert no unknown options.
+ * @param {Record<string, import("./query.js").FrontendModelTransportValue | (() => void) | undefined>} restOptions - Unknown options object.
+ * @returns {void}
+ */
+function assertNoUnknownOptions(restOptions) {
+  const unknownOptionNames = Object.keys(restOptions)
+
+  if (unknownOptionNames.length > 0) {
+    throw new Error(`Unknown options given to useUpdatedEvent: ${unknownOptionNames.join(", ")}`)
+  }
+}
+
+/**
+ * Runs event query dependency payload.
+ * @param {import("./query.js").default<FrontendModelClass> | undefined} query - Event query option.
+ * @returns {import("./query.js").FrontendModelEventOptionsPayload | null} Stable dependency payload.
+ */
+function eventQueryDependencyPayload(query) {
+  if (!query) return null
+
+  return query.eventOptionsPayload()
+}
+
+/**
+ * React hook for frontend-model update events. Pass a model class for class-level
+ * update events, or a model / model array for instance-level update events.
+ * @param {FrontendModelClass | FrontendModelInstance | FrontendModelInstance[] | null | undefined} modelClassOrModels - Model class, model, or models.
+ * @param {FrontendModelUpdateEventCallback} callback - Event callback.
+ * @param {UseUpdatedEventOptions} [options] - Hook options.
+ * @returns {void}
+ */
+export default function useUpdatedEvent(modelClassOrModels, callback, options = {}) {
+  const {active = true, abilities, debounce = false, onConnected, preload, query, queryData, select, selectsExtra, withCount, ...restOptions} = options
+  assertNoUnknownOptions(restOptions)
+
+  const classModel = typeof modelClassOrModels === "function" ? modelClassOrModels : null
+  const instanceModels = typeof modelClassOrModels === "function" ? null : modelClassOrModels
+  const projectionOptions = {abilities, preload, query, queryData, select, selectsExtra, withCount}
+
+  useModelClassEvent(classModel, "update", (payload) => {
+    callback(/**
+              * Narrows the runtime value to the documented type.
+               @type {FrontendModelClassUpdateEventPayload} */ (payload))
+  }, {active: active && Boolean(classModel), debounce, onConnected, ...projectionOptions})
+  useInstanceUpdatedEvent(instanceModels, callback, {active: active && !classModel, debounce, onConnected, ...projectionOptions})
+}
+
+/**
+ * Runs use instance updated event.
+ * @param {FrontendModelInstance | FrontendModelInstance[] | null | undefined} modelOrModels - Model or models.
+ * @param {FrontendModelUpdateEventCallback} callback - Event callback.
+ * @param {UseUpdatedEventOptions} options - Hook options.
+ * @returns {void}
+ */
+function useInstanceUpdatedEvent(modelOrModels, callback, options) {
+  const {active = true, abilities, debounce = false, onConnected, preload, query, queryData, select, selectsExtra, withCount} = options
+  const projectionKey = JSON.stringify({abilities, preload, query: eventQueryDependencyPayload(query), queryData, select, selectsExtra, withCount})
+  const projectionOptionsRef = useRef({abilities, preload, query, queryData, select, selectsExtra, withCount})
+  const callbackRef = useRef(callback)
+  const activeRef = useRef(active)
+  projectionOptionsRef.current = {abilities, preload, query, queryData, select, selectsExtra, withCount}
+  callbackRef.current = callback
+  activeRef.current = active
+
+  const modelsKey = modelsDependencyKey(modelOrModels)
+  const eventCallback = useMemo(() => {
+    const wrappedCallback = (/**
+                              * Narrows the runtime value to the documented type.
+                               @type {FrontendModelInstanceUpdateEventPayload} */ payload) => {
+      if (activeRef.current) callbackRef.current(payload)
+    }
+
+    if (typeof debounce === "number") return debounceFunction(wrappedCallback, debounce)
+    if (debounce) return debounceFunction(wrappedCallback)
+
+    return wrappedCallback
+  }, [debounce])
+
+  useEffect(() => {
+    if (!active) return undefined
+
+    const models = modelsFromInput(modelOrModels)
+    if (models.length < 1) return undefined
+
+    let closed = false
+    /**
+     * Unsubscribe callbacks.
+      @type {Array<() => void>} */
+    const unsubscribeCallbacks = []
+    const subscriptionCallback = (/**
+                                   * Narrows the runtime value to the documented type.
+                                    @type {FrontendModelInstanceUpdateEventPayload} */ payload) => {
+      if (!closed) eventCallback(payload)
+    }
+
+    void (async () => {
+      for (const model of models) {
+        const unsubscribe = await model.onUpdate(subscriptionCallback, projectionOptionsRef.current)
+
+        if (closed) {
+          unsubscribe()
+        } else {
+          unsubscribeCallbacks.push(unsubscribe)
+        }
+      }
+
+      if (!closed && onConnected) onConnected()
+    })()
+
+    return () => {
+      closed = true
+
+      for (const unsubscribe of unsubscribeCallbacks) {
+        unsubscribe()
+      }
+
+      clearPendingDebouncedCallback(eventCallback)
+    }
+  }, [active, eventCallback, modelsKey, onConnected, projectionKey])
+}

package/src/frontend-models/websocket-channel.js

@@ -0,0 +1,494 @@
+// @ts-check
+
+import VelociousWebsocketChannel from "../http-server/websocket-channel.js"
+import Response from "../http-server/client/response.js"
+import {serializeFrontendModelTransportValue} from "./transport-serialization.js"
+
+const EVENT_FILTER_KEYS = new Set(["joins", "key", "searches", "where"])
+
+/**
+ * Defines this typedef.
+ * @typedef {{action?: string, id?: string | number, matchedEventFilterKeys?: string[], record?: import("./query.js").FrontendModelTransportValue, [key: string]: import("./query.js").FrontendModelTransportValue | string[] | undefined}} FrontendModelLifecycleBroadcastBody
+ */
+/**
+ * Defines this typedef.
+ * @typedef {{headers?: () => Record<string, string | string[] | undefined>, remoteAddress?: () => string | undefined}} FrontendModelWebsocketUpgradeRequest
+ */
+/**
+ * Defines this typedef.
+ * @typedef {{headers: () => Record<string, string | string[] | undefined>, header: (name: string) => string | string[] | undefined, metadata: (key?: string) => Record<string, import("./query.js").FrontendModelTransportValue> | import("./query.js").FrontendModelTransportValue | undefined, path: () => string, httpMethod: () => string, remoteAddress: () => string | undefined, origin: () => string | string[] | undefined}} FrontendModelWebsocketSyntheticRequest
+ */
+
+/**
+ * Per-session channel subscription for frontend-model lifecycle events.
+ * Replaces the legacy `FrontendModelWebsocketChannel` (Phase 3).
+ *
+ * Auth model: subscribe-time only. `canSubscribe` resolves the caller's
+ * ability once, checks that at least one `allow` rule exists for
+ * `read` on the requested model class, and then delivers future
+ * lifecycle broadcasts for that model without re-authorizing per event.
+ * This matches the explicit design decision in Phase 3 to trade
+ * per-record visibility guarantees for massively cheaper broadcast fan-out.
+ * Subscriber-provided event filters can still narrow which create/update
+ * events are delivered, but they are matching predicates rather than
+ * per-record authorization checks.
+ *
+ * Wire: subscribe with `subscribeChannel("frontend-models", {params: {model: ModelName}})`.
+ * Backend publishes `{action, id, record}` via
+ * `configuration.broadcastToChannel("frontend-models", {model: ModelName}, body)`;
+ * `matches()` routes by model name.
+ */
+export default class FrontendModelWebsocketChannel extends VelociousWebsocketChannel {
+  /**
+   * Ability.
+    @type {import("../authorization/ability.js").default | null} */
+  _ability = null
+
+  /**
+   * Runs can subscribe.
+   * @returns {Promise<boolean>} Whether the frontend-model subscription is authorized.
+   */
+  async canSubscribe() {
+    const modelName = this._modelName()
+
+    if (!modelName) return false
+    this._eventFilters()
+
+    const configuration = this.session.configuration
+    const modelClasses = configuration.getModelClasses?.() || {}
+    const ModelClass = modelClasses[modelName]
+
+    if (!ModelClass) return false
+
+    const ability = await configuration.resolveAbility?.({
+      params: {model: modelName},
+      request: /**
+                * Narrows the runtime value to the documented type.
+                 @type {import("../http-server/client/request.js").default} */ (this._syntheticRequest()),
+      response: new Response({configuration})
+    })
+
+    if (!ability) return false
+    this._ability = ability
+
+    // Load resource-declared rules for this model class before checking,
+    // otherwise `rulesFor` returns empty for abilities whose resources
+    // register rules lazily via `abilities()`.
+    if (typeof ability.loadAbilitiesForModelClass === "function") {
+      ability.loadAbilitiesForModelClass(ModelClass)
+    }
+
+    const readRules = typeof ability.rulesFor === "function"
+      ? ability.rulesFor({action: "read", modelClass: ModelClass})
+      : []
+
+    return readRules.some((/**
+                            * Narrows the runtime value to the documented type.
+                             @type {{effect: string}} */ rule) => rule.effect === "allow")
+  }
+
+  /**
+   * Runs deliver broadcast.
+   * @param {FrontendModelLifecycleBroadcastBody} body - Broadcast body.
+   * @param {{eventId?: string}} [meta] - Optional event metadata.
+   * @returns {Promise<void>} Resolves after delivery.
+   */
+  async deliverBroadcast(body, meta) {
+    const configuration = this.session.configuration
+
+    if (configuration && typeof configuration.ensureConnections === "function") {
+      await configuration.ensureConnections({name: "Frontend model websocket broadcast"}, async () => {
+        await this._deliverBroadcast(body, meta)
+      })
+      return
+    }
+
+    await this._deliverBroadcast(body, meta)
+  }
+
+  /**
+   * Runs deliver broadcast.
+   * @param {FrontendModelLifecycleBroadcastBody} body - Broadcast body.
+   * @param {{eventId?: string}} [meta] - Optional event metadata.
+   * @returns {Promise<void>} Resolves after delivery.
+   */
+  async _deliverBroadcast(body, meta) {
+    const hasEventFilters = this._hasEventFilterParams()
+
+    if (!this._hasProjectionParams() && !hasEventFilters) {
+      this.sendMessage(body, meta)
+      return
+    }
+
+    if (!body || typeof body !== "object") {
+      if (!hasEventFilters || this._hasUnfilteredEventDelivery()) this.sendMessage(body, meta)
+      return
+    }
+
+    if (body.action === "destroy") {
+      if (!hasEventFilters || this._hasUnfilteredEventDelivery()) this.sendMessage(body, meta)
+      return
+    }
+
+    if (body.id === undefined || body.id === null) {
+      if (!hasEventFilters || this._hasUnfilteredEventDelivery()) this.sendMessage(body, meta)
+      return
+    }
+
+    const FrontendModelController = await this._frontendModelControllerClass()
+    const matchedEventFilterKeys = await this._matchedEventFilterKeysForEventId(body.id, FrontendModelController)
+
+    if (hasEventFilters && matchedEventFilterKeys.length === 0 && !this._hasUnfilteredEventDelivery()) {
+      return
+    }
+
+    /**
+     * Deliver body.
+      @type {FrontendModelLifecycleBroadcastBody} */
+    let deliverBody = body
+
+    if (this._hasProjectionParams()) {
+      const projectedRecord = await this._projectedRecordForEventId(body.id, FrontendModelController)
+
+      if (!projectedRecord) {
+        return
+      }
+
+      deliverBody = {
+        ...deliverBody,
+        record: /**
+                 * Narrows the runtime value to the documented type.
+                  @type {import("./query.js").FrontendModelTransportValue} */ (serializeFrontendModelTransportValue(projectedRecord))
+      }
+    }
+
+    if (hasEventFilters) {
+      deliverBody = {
+        ...deliverBody,
+        matchedEventFilterKeys
+      }
+    }
+
+    this.sendMessage(deliverBody, meta)
+  }
+
+  /**
+   * Runs matches.
+   * @param {Record<string, import("./query.js").FrontendModelTransportValue>} broadcastParams - Params from `broadcastToChannel`.
+   * @returns {boolean} Whether the broadcast matches this subscriber's model.
+   */
+  matches(broadcastParams) {
+    return broadcastParams?.model === this._modelName()
+  }
+
+  /**
+   * Runs debug snapshot.
+   * @returns {Record<string, ?>} Debug-safe subscription details.
+   */
+  debugSnapshot() {
+    const eventFilters = this._eventFilters()
+
+    return {
+      abilities: this.params.abilities !== undefined,
+      eventFilterCount: eventFilters.length,
+      model: this._modelName(),
+      preload: this.params.preload !== undefined,
+      queryData: this.params.queryData !== undefined,
+      select: this.params.select !== undefined,
+      selectsExtra: this.params.selectsExtra !== undefined,
+      unfilteredEventDelivery: this.params.unfilteredEventDelivery === true,
+      withCount: this.params.withCount !== undefined
+    }
+  }
+
+  /**
+   * Runs model name.
+   * @returns {string | null} - Requested frontend-model name or null.
+   */
+  _modelName() {
+    return typeof this.params?.model === "string" && this.params.model.length > 0
+      ? this.params.model
+      : null
+  }
+
+  /**
+   * Runs has projection params.
+   * @returns {boolean} - Whether this subscription requested per-event record projection.
+   */
+  _hasProjectionParams() {
+    return this.params.select !== undefined
+      || this.params.selectsExtra !== undefined
+      || this.params.preload !== undefined
+      || this.params.withCount !== undefined
+      || this.params.abilities !== undefined
+      || this.params.queryData !== undefined
+  }
+
+  /**
+   * Runs has event filter params.
+   * @returns {boolean} - Whether this subscription requested event query filters.
+   */
+  _hasEventFilterParams() {
+    return this._eventFilters().length > 0
+  }
+
+  /**
+   * Runs has unfiltered event delivery.
+   * @returns {boolean} - Whether unfiltered callbacks should receive every event.
+   */
+  _hasUnfilteredEventDelivery() {
+    return this.params.unfilteredEventDelivery === true
+  }
+
+  /**
+   * Runs event filters.
+   * @returns {import("./query.js").FrontendModelEventFilterPayloadEntry[]} - Valid event filters.
+   */
+  _eventFilters() {
+    if (this.params.eventFilters === undefined) return []
+    if (!Array.isArray(this.params.eventFilters)) {
+      throw new Error("Frontend model eventFilters must be an array")
+    }
+
+    return this.params.eventFilters.map((entry) => {
+      if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+        throw new Error("Frontend model eventFilters entries must be objects")
+      }
+
+      const eventFilter = /**
+                           * Narrows the runtime value to the documented type.
+                            @type {Record<string, ?>} */ (entry)
+      const unknownKeys = Object.keys(eventFilter).filter((key) => !EVENT_FILTER_KEYS.has(key))
+
+      if (unknownKeys.length > 0) {
+        throw new Error(`Frontend model eventFilters entries cannot include ${unknownKeys.join(", ")}`)
+      }
+
+      if (typeof eventFilter.key !== "string" || eventFilter.key.length === 0) {
+        throw new Error("Frontend model eventFilters entries require a key")
+      }
+
+      /**
+       * Sanitized event filter.
+        @type {import("./query.js").FrontendModelEventFilterPayloadEntry} */
+      const sanitizedEventFilter = {key: eventFilter.key}
+
+      if (eventFilter.joins !== undefined) {
+        sanitizedEventFilter.joins = /**
+                                      * Narrows the runtime value to the documented type.
+                                       @type {Record<string, import("./query.js").FrontendModelTransportValue>} */ (eventFilter.joins)
+      }
+
+      if (eventFilter.searches !== undefined) {
+        sanitizedEventFilter.searches = /**
+                                         * Narrows the runtime value to the documented type.
+                                          @type {import("./query.js").FrontendModelSearch[]} */ (eventFilter.searches)
+      }
+
+      if (eventFilter.where !== undefined) {
+        sanitizedEventFilter.where = /**
+                                      * Narrows the runtime value to the documented type.
+                                       @type {Record<string, import("./query.js").FrontendModelTransportValue>} */ (eventFilter.where)
+      }
+
+      return sanitizedEventFilter
+    })
+  }
+
+  /**
+   * Runs frontend model controller class.
+   * @returns {Promise<typeof import("../frontend-model-controller.js").default>} - Frontend model controller class.
+   */
+  async _frontendModelControllerClass() {
+    const frontendModelControllerPath = "../frontend-model-controller.js"
+    const {default: FrontendModelController} = await import(frontendModelControllerPath)
+
+    return FrontendModelController
+  }
+
+  /**
+   * Runs frontend model controller.
+   * @param {typeof import("../frontend-model-controller.js").default} FrontendModelController - Server-side frontend-model controller class.
+   * @param {Record<string, ?>} [params] - Optional params override.
+   * @returns {import("../frontend-model-controller.js").default} - Synthetic controller used for resource serialization.
+   */
+  _frontendModelController(FrontendModelController, params = {}) {
+    const configuration = this.session.configuration
+    const controller = new FrontendModelController({
+      action: "websocketEvent",
+      configuration,
+      controller: "frontend-models",
+      params: {
+        abilities: this.params.abilities,
+        joins: this.params.joins,
+        model: this._modelName(),
+        preload: this.params.preload,
+        queryData: this.params.queryData,
+        searches: this.params.searches,
+        select: this.params.select,
+        selectsExtra: this.params.selectsExtra,
+        where: this.params.where,
+        ...params,
+        withCount: this.params.withCount
+      },
+      request: /**
+                * Narrows the runtime value to the documented type.
+                 @type {import("../http-server/client/request.js").default} */ (this._syntheticRequest()),
+      response: new Response({configuration}),
+      viewPath: "/"
+    })
+
+    controller._frontendModelAbilityOverride = this._ability || undefined
+
+    return controller
+  }
+
+  /**
+   * Runs matched event filter keys for event id.
+   * @param {string | number} id - Event record id.
+   * @param {typeof import("../frontend-model-controller.js").default} FrontendModelController - Server-side frontend-model controller class.
+   * @returns {Promise<string[]>} - Event filter keys matched by the record.
+   */
+  async _matchedEventFilterKeysForEventId(id, FrontendModelController) {
+    /**
+     * Matched event filter keys.
+      @type {string[]} */
+    const matchedEventFilterKeys = []
+
+    for (const eventFilter of this._eventFilters()) {
+      const matches = await this._eventMatchesFilter({
+        FrontendModelController,
+        eventFilter,
+        id
+      })
+
+      if (matches) matchedEventFilterKeys.push(eventFilter.key)
+    }
+
+    return matchedEventFilterKeys
+  }
+
+  /**
+   * Runs event matches filter.
+   * @param {object} args - Filter args.
+   * @param {typeof import("../frontend-model-controller.js").default} args.FrontendModelController - Server-side frontend-model controller class.
+   * @param {import("./query.js").FrontendModelEventFilterPayloadEntry} args.eventFilter - Event filter payload.
+   * @param {string | number} args.id - Event record id.
+   * @returns {Promise<boolean>} Whether the record matches the filter.
+   */
+  async _eventMatchesFilter({FrontendModelController, eventFilter, id}) {
+    const controller = this._frontendModelController(FrontendModelController, {
+      joins: eventFilter.joins,
+      searches: eventFilter.searches,
+      where: eventFilter.where
+    })
+
+    await controller.ensureFrontendModelClassInitialized()
+
+    const ModelClass = controller.frontendModelClass()
+    const primaryKey = ModelClass.primaryKey()
+    const where = controller.frontendModelWhere()
+    const joins = controller.frontendModelJoins()
+    let query = ModelClass.where({[ModelClass.tableName()]: {[primaryKey]: id}})
+
+    if (where) controller.applyFrontendModelWhere({query, where})
+    if (joins) controller.applyFrontendModelJoins({joins, query})
+
+    for (const search of controller.frontendModelSearches()) {
+      controller.applyFrontendModelSearch({query, search})
+    }
+
+    return Boolean(await query.first())
+  }
+
+  /**
+   * Runs projected record for event id.
+   * @param {string | number} id - Event record id.
+   * @param {typeof import("../frontend-model-controller.js").default} FrontendModelController - Server-side frontend-model controller class.
+   * @returns {Promise<Record<string, import("./query.js").FrontendModelTransportValue> | null>} - Serialized projected record.
+   */
+  async _projectedRecordForEventId(id, FrontendModelController) {
+    const controller = this._frontendModelController(FrontendModelController)
+
+    await controller.ensureFrontendModelClassInitialized()
+
+    const ModelClass = controller.frontendModelClass()
+    const primaryKey = ModelClass.primaryKey()
+    let query = ModelClass.where({[ModelClass.tableName()]: {[primaryKey]: id}})
+    const preload = controller.frontendModelPreload()
+
+    if (preload) query = query.preload(preload)
+
+    for (const entry of controller.frontendModelWithCount()) {
+      /**
+       * Spec.
+        @type {Record<string, boolean | {relationship?: string, where?: Record<string, import("./query.js").FrontendModelTransportValue>}>} */
+      const spec = {}
+
+      spec[entry.attributeName] = {
+        relationship: entry.relationshipName,
+        where: entry.where ? /**
+                              * Narrows the runtime value to the documented type.
+                               @type {Record<string, import("./query.js").FrontendModelTransportValue>} */ (entry.where) : undefined
+      }
+      query.withCount(spec)
+    }
+
+    const queryData = controller.frontendModelQueryData()
+
+    if (queryData !== null) query.queryData(queryData)
+
+    query = controller.applyFrontendModelTranslatedAttributePreloads({query})
+
+    const model = await query.first()
+
+    if (!model) return null
+
+    if (this.params.abilities !== undefined) {
+      await controller.frontendModelComputeAbilities([model])
+    }
+
+    controller._frontendModelAbilityOverride = undefined
+
+    return await controller.frontendModelResourceInstance().serialize(model, "find")
+  }
+
+  /**
+   * Minimal Request-like stub used only for ability resolution. Avoids
+   * importing `WebsocketRequest` here because its `node:querystring`
+   * dependency would pull server-only code into browser bundles via
+   * the `configuration → logger → websocket-publishers` import chain.
+   * Header names are normalized to lowercase so `header("cookie")`
+   * finds a value regardless of whether the upgrade-request headers
+   * map uses `"Cookie"` or `"cookie"`. Session metadata stays separate
+   * from headers and is exposed through `metadata(...)` for ability
+   * resolvers that need websocket-delivered session data.
+   * @returns {FrontendModelWebsocketSyntheticRequest} Request-like object for ability resolution.
+   */
+  _syntheticRequest() {
+    const upgradeRequest = /**
+                            * Narrows the runtime value to the documented type.
+                             @type {FrontendModelWebsocketUpgradeRequest} */ (this.session.upgradeRequest)
+    const rawHeaders = typeof upgradeRequest?.headers === "function" ? upgradeRequest.headers() : {}
+    const metadata = typeof this.session.getMetadata === "function" ? this.session.getMetadata() : {}
+    const remoteAddress = typeof upgradeRequest?.remoteAddress === "function" ? upgradeRequest.remoteAddress() : undefined
+    /**
+     * Header map.
+      @type {Record<string, string | string[] | undefined>} */
+    const headerMap = {}
+
+    for (const key of Object.keys(rawHeaders || {})) {
+      headerMap[key.toLowerCase()] = rawHeaders[key]
+    }
+
+    return {
+      headers: () => headerMap,
+      header: (name) => headerMap[String(name).toLowerCase()],
+      metadata: (key) => key === undefined ? {...metadata} : metadata[key],
+      path: () => "/frontend-models",
+      httpMethod: () => "POST",
+      remoteAddress: () => remoteAddress,
+      origin: () => headerMap.origin
+    }
+  }
+}