velocious 1.0.472 → 1.0.474

package/src/frontend-model-resource/base-resource.js

@@ -148,6 +148,8 @@ export default class FrontendModelBaseResource extends AuthorizationBaseResource
   /** @type {Record<string, ?> | undefined} */
   static attachments = undefined
   /** @type {string[] | undefined} */
+  static commands = undefined
+  /** @type {string[] | undefined} */
   static collectionCommands = undefined
   /** @type {string[] | undefined} */
   static builtInCollectionCommands = undefined
@@ -157,8 +159,16 @@ export default class FrontendModelBaseResource extends AuthorizationBaseResource
   static builtInMemberCommands = undefined
   /** @type {string[] | undefined} */
   static relationships = undefined
+  /** @type {string | undefined} */
+  static modelName = undefined
+  /** @type {string | undefined} */
+  static primaryKey = undefined
+  /** @type {import("../configuration-types.js").FrontendModelResourceServerConfiguration | undefined} */
+  static server = undefined
   /** @type {string[] | undefined} */
   static translatedAttributes = undefined
+  /** @type {?} */
+  static SharedResource = undefined
 
   /**
    * Runs constructor.
@@ -179,6 +189,149 @@ export default class FrontendModelBaseResource extends AuthorizationBaseResource
     this.modelNameValue = "modelName" in args ? args.modelName : this.modelClass().getModelName()
     this.paramsValue = "params" in args ? args.params : undefined
     this.resourceConfigurationValue = "resourceConfiguration" in args ? args.resourceConfiguration : defaultResourceConfiguration
+    /** @type {FrontendModelBaseResource | null | undefined} */
+    this.sharedResourceInstanceValue = undefined
+  }
+
+  /**
+   * Returns the configured shared resource class.
+   * @returns {?} - Shared resource class.
+   */
+  static sharedResourceClass() {
+    return this.SharedResource
+  }
+
+  /**
+   * Reads a static resource config value from the environment resource first,
+   * then from the shared resource.
+   * @param {"abilities" | "attachments" | "attributes" | "builtInCollectionCommands" | "builtInMemberCommands" | "collectionCommands" | "commands" | "memberCommands" | "modelName" | "primaryKey" | "relationships" | "server" | "translatedAttributes"} name - Static config property name.
+   * @returns {?} - Resolved config value.
+   */
+  static sharedResourceStaticValue(name) {
+    if (this[name] !== undefined) return this[name]
+
+    const SharedResource = /** @type {typeof FrontendModelBaseResource | undefined} */ (this.sharedResourceClass())
+
+    if (!SharedResource) return undefined
+    if (SharedResource[name] !== undefined) return SharedResource[name]
+
+    return undefined
+  }
+
+  /**
+   * Resolves translated attributes from environment and shared resources.
+   * @returns {string[] | undefined} - Translated attribute names.
+   */
+  static translatedAttributesConfig() {
+    return /** @type {string[] | undefined} */ (this.sharedResourceStaticValue("translatedAttributes"))
+  }
+
+  /**
+   * Builds a resource instance for shared-resource fallback calls.
+   * @returns {FrontendModelBaseResource | null} - Shared resource instance when configured.
+   */
+  sharedResourceInstance() {
+    if (this.sharedResourceInstanceValue !== undefined) return this.sharedResourceInstanceValue
+
+    const ResourceClass = /** @type {typeof FrontendModelBaseResource} */ (this.constructor)
+    const SharedResource = /** @type {typeof FrontendModelBaseResource | undefined} */ (ResourceClass.sharedResourceClass())
+
+    if (!SharedResource) {
+      this.sharedResourceInstanceValue = null
+      return this.sharedResourceInstanceValue
+    }
+
+    if (SharedResource === ResourceClass) {
+      throw new Error(`${ResourceClass.name}.SharedResource cannot point to itself.`)
+    }
+
+    this.sharedResourceInstanceValue = new SharedResource({
+      ability: this.ability,
+      controller: this.controller,
+      context: this.context,
+      locals: this.locals,
+      modelClass: this.modelClass(),
+      modelName: this.modelName(),
+      params: this.params(),
+      resourceConfiguration: this.resourceConfiguration()
+    })
+
+    return this.sharedResourceInstanceValue
+  }
+
+  /**
+   * Calls a shared-resource method only when the shared resource overrides the framework default.
+   * @param {string} methodName - Method name to resolve.
+   * @param {unknown[]} args - Method args.
+   * @returns {{called: boolean, result: unknown}} - Shared method call result.
+   */
+  callSharedResourceMethod(methodName, args) {
+    const sharedResource = this.sharedResourceInstance()
+
+    if (!sharedResource) return {called: false, result: undefined}
+
+    const methodOwner = prototypeOwnerForMethod(sharedResource, methodName)
+
+    if (!methodOwner || methodOwner === FrontendModelBaseResource.prototype || methodOwner === AuthorizationBaseResource.prototype) {
+      return {called: false, result: undefined}
+    }
+
+    const method = /** @type {Record<string, (...methodArgs: unknown[]) => unknown>} */ (/** @type {unknown} */ (sharedResource))[methodName]
+
+    return {called: true, result: method.apply(sharedResource, args)}
+  }
+
+  /**
+   * Runs shared method result or a fallback callback.
+   * @template Result
+   * @param {string} methodName - Shared method name.
+   * @param {unknown[]} args - Shared method args.
+   * @param {() => Result} fallback - Fallback callback.
+   * @returns {Result} - Shared or fallback result.
+   */
+  sharedResourceMethodOr(methodName, args, fallback) {
+    const sharedResult = this.callSharedResourceMethod(methodName, args)
+
+    if (sharedResult.called) return /** @type {Result} */ (sharedResult.result)
+
+    return fallback()
+  }
+
+  /**
+   * Resolves a method on this resource or its shared fallback.
+   * @param {string} methodName - Method name.
+   * @returns {{method: (...methodArgs: unknown[]) => unknown, resource: FrontendModelBaseResource} | null} - Resolved method and receiver.
+   */
+  resourceMethod(methodName) {
+    const ownMethod = /** @type {Record<string, unknown>} */ (/** @type {unknown} */ (this))[methodName]
+
+    if (typeof ownMethod === "function") {
+      return {
+        method: /** @type {(...methodArgs: unknown[]) => unknown} */ (ownMethod),
+        resource: this
+      }
+    }
+
+    const sharedResource = this.sharedResourceInstance()
+
+    if (!sharedResource) return null
+
+    const sharedMethod = /** @type {Record<string, unknown>} */ (/** @type {unknown} */ (sharedResource))[methodName]
+
+    if (typeof sharedMethod !== "function") return null
+
+    return {
+      method: /** @type {(...methodArgs: unknown[]) => unknown} */ (sharedMethod),
+      resource: sharedResource
+    }
+  }
+
+  /**
+   * Runs abilities.
+   * @returns {void} - No return value.
+   */
+  abilities() {
+    this.sharedResourceMethodOr("abilities", [], () => undefined)
   }
 
   /**
@@ -194,18 +347,34 @@ export default class FrontendModelBaseResource extends AuthorizationBaseResource
    * @returns {import("../configuration-types.js").FrontendModelResourceConfiguration} - Static resource config (raw user input shape; consumers normalize).
    */
   static resourceConfig() {
+    const attributes = this.sharedResourceStaticValue("attributes")
+    const abilities = this.sharedResourceStaticValue("abilities")
+    const attachments = this.sharedResourceStaticValue("attachments")
+    const commands = this.sharedResourceStaticValue("commands")
+    const builtInCollectionCommands = this.sharedResourceStaticValue("builtInCollectionCommands")
+    const builtInMemberCommands = this.sharedResourceStaticValue("builtInMemberCommands")
+    const collectionCommands = this.sharedResourceStaticValue("collectionCommands")
+    const memberCommands = this.sharedResourceStaticValue("memberCommands")
+    const modelName = this.sharedResourceStaticValue("modelName")
+    const primaryKey = this.sharedResourceStaticValue("primaryKey")
+    const relationships = this.sharedResourceStaticValue("relationships")
+    const server = this.sharedResourceStaticValue("server")
     /** @type {import("../configuration-types.js").FrontendModelResourceConfiguration} */
     const config = {
-      attributes: this.attributes || []
+      attributes: /** @type {Record<string, ?> | string[]} */ (attributes || [])
     }
 
-    if (this.abilities) config.abilities = this.abilities
-    if (this.attachments) config.attachments = this.attachments
-    if (this.builtInCollectionCommands) config.builtInCollectionCommands = this.builtInCollectionCommands
-    if (this.builtInMemberCommands) config.builtInMemberCommands = this.builtInMemberCommands
-    if (this.collectionCommands) config.collectionCommands = this.collectionCommands
-    if (this.memberCommands) config.memberCommands = this.memberCommands
-    if (this.relationships) config.relationships = this.relationships
+    if (abilities) config.abilities = /** @type {string[]} */ (abilities)
+    if (attachments) config.attachments = /** @type {Record<string, ?>} */ (attachments)
+    if (commands) config.commands = /** @type {string[]} */ (commands)
+    if (builtInCollectionCommands) config.builtInCollectionCommands = /** @type {string[]} */ (builtInCollectionCommands)
+    if (builtInMemberCommands) config.builtInMemberCommands = /** @type {string[]} */ (builtInMemberCommands)
+    if (collectionCommands) config.collectionCommands = /** @type {string[]} */ (collectionCommands)
+    if (memberCommands) config.memberCommands = /** @type {string[]} */ (memberCommands)
+    if (modelName) config.modelName = /** @type {string} */ (modelName)
+    if (primaryKey) config.primaryKey = /** @type {string} */ (primaryKey)
+    if (relationships) config.relationships = /** @type {string[]} */ (relationships)
+    if (server) config.server = /** @type {import("../configuration-types.js").FrontendModelResourceServerConfiguration} */ (server)
 
     return config
   }
@@ -242,6 +411,14 @@ export default class FrontendModelBaseResource extends AuthorizationBaseResource
     return /** @type {TModelClass} */ (this.modelClassValue)
   }
 
+  /**
+   * Runs required model class for authorization helpers.
+   * @returns {TModelClass} - Backing model class.
+   */
+  requiredModelClass() {
+    return this.modelClass()
+  }
+
   /**
    * Runs model name.
    * @returns {string} - Model name.
@@ -307,9 +484,11 @@ export default class FrontendModelBaseResource extends AuthorizationBaseResource
    * @returns {Array<string | Record<string, ?>>} - Permit spec.
    */
   permittedParams(arg) {
-    void arg
+    return this.sharedResourceMethodOr("permittedParams", [arg], () => {
+      void arg
 
-    return []
+      return []
+    })
   }
 
   /**
@@ -319,9 +498,11 @@ export default class FrontendModelBaseResource extends AuthorizationBaseResource
    * @returns {FrontendModelResourceAttributePayload | Promise<FrontendModelResourceAttributePayload>} - Normalized attributes.
    */
   normalizeCreateAttributes(attributes, options) {
-    void options
+    return this.sharedResourceMethodOr("normalizeCreateAttributes", [attributes, options], () => {
+      void options
 
-    return attributes
+      return attributes
+    })
   }
 
   /**
@@ -332,10 +513,12 @@ export default class FrontendModelBaseResource extends AuthorizationBaseResource
    * @returns {FrontendModelResourceAttributePayload | Promise<FrontendModelResourceAttributePayload>} - Normalized attributes.
    */
   normalizeUpdateAttributes(model, attributes, options) {
-    void model
-    void options
+    return this.sharedResourceMethodOr("normalizeUpdateAttributes", [model, attributes, options], () => {
+      void model
+      void options
 
-    return attributes
+      return attributes
+    })
   }
 
   /**
@@ -346,9 +529,11 @@ export default class FrontendModelBaseResource extends AuthorizationBaseResource
    * @returns {void | Promise<void>} - Resolves when the hook finishes.
    */
   beforeCreate(model, attributes, options) {
-    void model
-    void attributes
-    void options
+    return this.sharedResourceMethodOr("beforeCreate", [model, attributes, options], () => {
+      void model
+      void attributes
+      void options
+    })
   }
 
   /**
@@ -359,9 +544,11 @@ export default class FrontendModelBaseResource extends AuthorizationBaseResource
    * @returns {void | Promise<void>} - Resolves when the hook finishes.
    */
   afterCreate(model, attributes, options) {
-    void model
-    void attributes
-    void options
+    return this.sharedResourceMethodOr("afterCreate", [model, attributes, options], () => {
+      void model
+      void attributes
+      void options
+    })
   }
 
   /**
@@ -372,9 +559,11 @@ export default class FrontendModelBaseResource extends AuthorizationBaseResource
    * @returns {void | Promise<void>} - Resolves when the hook finishes.
    */
   beforeUpdate(model, attributes, options) {
-    void model
-    void attributes
-    void options
+    return this.sharedResourceMethodOr("beforeUpdate", [model, attributes, options], () => {
+      void model
+      void attributes
+      void options
+    })
   }
 
   /**
@@ -385,9 +574,11 @@ export default class FrontendModelBaseResource extends AuthorizationBaseResource
    * @returns {void | Promise<void>} - Resolves when the hook finishes.
    */
   afterUpdate(model, attributes, options) {
-    void model
-    void attributes
-    void options
+    return this.sharedResourceMethodOr("afterUpdate", [model, attributes, options], () => {
+      void model
+      void attributes
+      void options
+    })
   }
 
   /**
@@ -396,7 +587,9 @@ export default class FrontendModelBaseResource extends AuthorizationBaseResource
    * @returns {void | Promise<void>} - Resolves when the hook finishes.
    */
   beforeDestroy(model) {
-    void model
+    return this.sharedResourceMethodOr("beforeDestroy", [model], () => {
+      void model
+    })
   }
 
   /**
@@ -405,7 +598,9 @@ export default class FrontendModelBaseResource extends AuthorizationBaseResource
    * @returns {void | Promise<void>} - Resolves when the hook finishes.
    */
   afterDestroy(model) {
-    void model
+    return this.sharedResourceMethodOr("afterDestroy", [model], () => {
+      void model
+    })
   }
 
   /**
@@ -418,10 +613,12 @@ export default class FrontendModelBaseResource extends AuthorizationBaseResource
    * @returns {Promise<Result>} - Callback result.
    */
   async runMutationTransaction({action, model, callback}) {
-    void action
-    void model
+    return await this.sharedResourceMethodOr("runMutationTransaction", [{action, model, callback}], async () => {
+      void action
+      void model
 
-    return await callback()
+      return await callback()
+    })
   }
 
   /**
@@ -517,9 +714,11 @@ export default class FrontendModelBaseResource extends AuthorizationBaseResource
    * @returns {boolean | void | Promise<boolean | void>} - Continue processing unless false.
    */
   beforeAction(action) {
-    void action
+    return this.sharedResourceMethodOr("beforeAction", [action], () => {
+      void action
 
-    // No-op by default.
+      // No-op by default.
+    })
   }
 
   /**
@@ -663,14 +862,14 @@ export default class FrontendModelBaseResource extends AuthorizationBaseResource
     /** @type {Record<string, ?>} */
     const directAttributes = {}
     const ResourceClass = /** @type {typeof FrontendModelBaseResource} */ (this.constructor)
-    const translatedSet = new Set(ResourceClass.translatedAttributes || [])
+    const translatedSet = new Set(ResourceClass.translatedAttributesConfig() || [])
 
     for (const [name, value] of Object.entries(attributes)) {
       const resourceSetterName = `set${inflection.camelize(name)}Attribute`
-      const resourceSetter = virtualSetterLookup(this)[resourceSetterName]
+      const resourceSetter = this.resourceMethod(resourceSetterName)
 
-      if (typeof resourceSetter === "function") {
-        await resourceSetter.call(this, model, value)
+      if (resourceSetter) {
+        await resourceSetter.method.call(resourceSetter.resource, model, value)
       } else if (translatedSet.has(name)) {
         await this._setTranslatedAttributeOnModel(model, name, value)
       } else {
@@ -1527,12 +1726,21 @@ function parsePermittedParams(permitSpec) {
 }
 
 /**
- * Narrows a resource to its dynamic virtual setter lookup surface.
- * @param {FrontendModelBaseResource} resource - Resource instance.
- * @returns {Record<string, FrontendModelResourceVirtualSetter>} Dynamic virtual setter lookup.
+ * Locates which prototype owns a method implementation.
+ * @param {object} instance - Instance receiving the method.
+ * @param {string} methodName - Method name.
+ * @returns {object | null} - Prototype that owns the method.
  */
-function virtualSetterLookup(resource) {
-  return /** @type {Record<string, FrontendModelResourceVirtualSetter>} */ (/** @type {unknown} */ (resource))
+function prototypeOwnerForMethod(instance, methodName) {
+  let prototype = Object.getPrototypeOf(instance)
+
+  while (prototype) {
+    if (Object.prototype.hasOwnProperty.call(prototype, methodName)) return prototype
+
+    prototype = Object.getPrototypeOf(prototype)
+  }
+
+  return null
 }
 
 /**
@@ -1567,7 +1775,7 @@ function filterWritableFrontendModelAttributes(
   if (resource) {
     const ResourceClass = /** @type {typeof FrontendModelBaseResource} */ (resource.constructor)
 
-    translatedAttributes = ResourceClass.translatedAttributes || []
+    translatedAttributes = ResourceClass.translatedAttributesConfig() || []
   }
 
   const translatedSet = new Set(translatedAttributes)
@@ -1582,11 +1790,11 @@ function filterWritableFrontendModelAttributes(
     const requestedSetterName = `set${inflection.camelize(resolvedAttributeName)}`
     const setterName = receiverClass.findMemberNameInsensitive(receiver, requestedSetterName) || requestedSetterName
     const resourceSetterName = `set${inflection.camelize(attributeName)}Attribute`
-    const resourceSetter = resource ? virtualSetterLookup(resource)[resourceSetterName] : undefined
+    const resourceSetter = resource?.resourceMethod(resourceSetterName)
 
     if (setterName in receiver) {
       writableAttributes[attributeName] = value
-    } else if (typeof resourceSetter === "function") {
+    } else if (resourceSetter) {
       writableAttributes[attributeName] = value
     } else if (translatedSet.has(attributeName)) {
       writableAttributes[attributeName] = value

package/src/frontend-model-resource/velocious-attachment-resource.js

@@ -26,9 +26,6 @@ export default class VelociousAttachmentResource extends FrontendModelBaseResour
     updatedAt: {type: "datetime"}
   }
 
-  /** @type {string[]} */
-  static abilities = ["read"]
-
   /** @type {string[]} */
   static builtInCollectionCommands = ["index"]
 

package/src/frontend-models/resource-definition.js

@@ -5,6 +5,25 @@ import FrontendModelBaseResource from "../frontend-model-resource/base-resource.
 import restArgsError from "../utils/rest-args-error.js"
 import {validateFrontendModelResourceCommandName} from "./resource-config-validation.js"
 
+const BASE_FRONTEND_MODEL_ABILITY_ACTIONS = ["create", "destroy", "read", "update"]
+const RESOURCE_STATIC_CONFIG_KEYS = new Set([
+  "abilities",
+  "attachments",
+  "attributes",
+  "builtInCollectionCommands",
+  "builtInMemberCommands",
+  "collectionCommands",
+  "commands",
+  "memberCommands",
+  "modelName",
+  "ModelClass",
+  "primaryKey",
+  "relationships",
+  "server",
+  "SharedResource",
+  "translatedAttributes"
+])
+
 /**
  * Runs the frontendModelResourcesForBackendProject helper.
  * @param {import("../configuration-types.js").BackendProjectConfiguration} backendProject - Backend project config.
@@ -50,9 +69,74 @@ export function frontendModelResourceClassFromDefinition(resourceDefinition) {
 export function frontendModelResourceConfigurationFromDefinition(resourceDefinition) {
   if (!frontendModelResourceDefinitionIsClass(resourceDefinition)) return null
 
+  assertResourceConfigIsFrameworkDefined(resourceDefinition)
+
   return normalizeFrontendModelResourceConfiguration(resourceDefinition.resourceConfig())
 }
 
+/**
+ * Ensures resources use declarative static config properties instead of overriding resourceConfig().
+ * @param {import("../configuration-types.js").FrontendModelResourceClassType} ResourceClass - Resource class.
+ * @param {Set<import("../configuration-types.js").FrontendModelResourceClassType>} [visited] - Already inspected shared resources.
+ * @returns {void}
+ */
+function assertResourceConfigIsFrameworkDefined(ResourceClass, visited = new Set()) {
+  if (visited.has(ResourceClass)) return
+
+  visited.add(ResourceClass)
+  assertKnownResourceStaticConfigProperties(ResourceClass)
+
+  const owner = staticMethodOwnerFor(ResourceClass, "resourceConfig")
+
+  if (owner && owner !== FrontendModelBaseResource) {
+    throw new Error(`${ResourceClass.name} overrides static resourceConfig(), which is not supported. Use static resource properties instead.`)
+  }
+
+  const SharedResource = ResourceClass.sharedResourceClass()
+
+  if (SharedResource) assertResourceConfigIsFrameworkDefined(SharedResource, visited)
+}
+
+/**
+ * Ensures declarative static resource config does not silently ignore typos or removed keys.
+ * @param {import("../configuration-types.js").FrontendModelResourceClassType} ResourceClass - Resource class.
+ * @returns {void}
+ */
+function assertKnownResourceStaticConfigProperties(ResourceClass) {
+  let currentClass = ResourceClass
+
+  while (currentClass && currentClass !== FrontendModelBaseResource && currentClass !== Function.prototype) {
+    /** @type {Record<string, ?>} */
+    const unknownStaticConfig = {}
+
+    for (const key of Object.keys(currentClass)) {
+      if (!RESOURCE_STATIC_CONFIG_KEYS.has(key)) unknownStaticConfig[key] = /** @type {Record<string, ?>} */ (/** @type {unknown} */ (currentClass))[key]
+    }
+
+    restArgsError(unknownStaticConfig)
+
+    currentClass = Object.getPrototypeOf(currentClass)
+  }
+}
+
+/**
+ * Locates which constructor owns a static method implementation.
+ * @param {import("../configuration-types.js").FrontendModelResourceClassType} ResourceClass - Resource class.
+ * @param {string} methodName - Method name.
+ * @returns {import("../configuration-types.js").FrontendModelResourceClassType | typeof FrontendModelBaseResource | null} - Class that owns the static method.
+ */
+function staticMethodOwnerFor(ResourceClass, methodName) {
+  let currentClass = ResourceClass
+
+  while (currentClass && currentClass !== Function.prototype) {
+    if (Object.prototype.hasOwnProperty.call(currentClass, methodName)) return currentClass
+
+    currentClass = Object.getPrototypeOf(currentClass)
+  }
+
+  return null
+}
+
 /**
  * Runs normalize frontend model resource configuration.
  * @param {import("../configuration-types.js").FrontendModelResourceConfiguration} resourceConfiguration - Raw resource configuration.
@@ -102,36 +186,27 @@ function normalizeFrontendModelResourceConfiguration(resourceConfiguration) {
  * @returns {Record<string, string>} - Normalized abilities config.
  */
 function normalizeFrontendModelResourceAbilities(abilities) {
-  if (abilities === undefined) {
-    return defaultCrudAbilities()
-  }
+  const normalized = defaultCrudAbilities()
+
+  if (abilities === undefined) return normalized
 
   if (!Array.isArray(abilities)) {
     throw new Error("Resource abilities must be an array of action names. Object form is no longer supported.")
   }
 
-  if (abilities.includes("manage")) {
-    return {
-      create: "manage",
-      destroy: "manage",
-      find: "manage",
-      index: "manage",
-      update: "manage"
-    }
+  const duplicatedBaseAbilities = abilities.filter((ability) => BASE_FRONTEND_MODEL_ABILITY_ACTIONS.includes(ability))
+
+  if (duplicatedBaseAbilities.length > 0) {
+    throw new Error(`Resource abilities must not include base actions: ${duplicatedBaseAbilities.join(", ")}`)
   }
 
-  /**
-   * Normalized.
-   * @type {Record<string, string>} */
-  const normalized = {}
+  for (const ability of abilities) {
+    if (typeof ability !== "string" || ability.length < 1) {
+      throw new Error("Resource abilities entries must be non-empty strings.")
+    }
 
-  if (abilities.includes("create")) normalized.create = "create"
-  if (abilities.includes("destroy")) normalized.destroy = "destroy"
-  if (abilities.includes("read")) {
-    normalized.find = "read"
-    normalized.index = "read"
+    normalized[ability] = ability
   }
-  if (abilities.includes("update")) normalized.update = "update"
 
   return normalized
 }

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

@@ -106,15 +106,6 @@ export default class FrontendModelWebsocketChannel extends VelociousWebsocketCha
    * @returns {Promise<void>} Resolves after delivery.
    */
   async deliverBroadcast(body, meta) {
-    const configuration = this.session.configuration
-
-    if (configuration) {
-      await configuration.ensureConnections({name: "Frontend model websocket broadcast"}, async () => {
-        await this._deliverBroadcast(body, meta)
-      })
-      return
-    }
-
     await this._deliverBroadcast(body, meta)
   }
 
@@ -367,6 +358,29 @@ export default class FrontendModelWebsocketChannel extends VelociousWebsocketCha
     return controller
   }
 
+  /**
+   * Resolves tenant for event.
+   * @param {string | number} id - Event record id.
+   * @returns {Promise<?>} - Resolved tenant.
+   */
+  async _resolveEventTenant(id) {
+    const configuration = this.session.configuration
+
+    return await configuration.ensureConnections({name: "Frontend model websocket event tenant resolution"}, async () => {
+      // Mirror the subscribe-time tenant resolution (`WebsocketSession._resolveTenant`):
+      // pass `subscription: {channel, params}` so resolvers that derive scope from the
+      // subscription behave the same for broadcasts as they did at `channel-subscribe`.
+      // The synthetic request forwards the subscriber's params (e.g. authenticationToken),
+      // matching this channel's ability resolution above.
+      return await configuration.resolveTenant({
+        params: {...this.params, id, model: this._modelName()},
+        request: /** @type {import("../http-server/client/request.js").default} */ (this._syntheticRequest()),
+        response: new Response({configuration}),
+        subscription: {channel: FRONTEND_MODELS_CHANNEL_NAME, params: this.params}
+      })
+    })
+  }
+
   /**
    * Resolves the subscriber's tenant for the broadcast record and runs `callback` inside that tenant
    * context. Broadcast delivery runs in whatever ambient tenant context the publisher left behind. For
@@ -388,17 +402,7 @@ export default class FrontendModelWebsocketChannel extends VelociousWebsocketCha
       return await callback()
     }
 
-    // Mirror the subscribe-time tenant resolution (`WebsocketSession._resolveTenant`):
-    // pass `subscription: {channel, params}` so resolvers that derive scope from the
-    // subscription behave the same for broadcasts as they did at `channel-subscribe`.
-    // The synthetic request forwards the subscriber's params (e.g. authenticationToken),
-    // matching this channel's ability resolution above.
-    const tenant = await configuration.resolveTenant({
-      params: {...this.params, id, model: this._modelName()},
-      request: /** @type {import("../http-server/client/request.js").default} */ (this._syntheticRequest()),
-      response: new Response({configuration}),
-      subscription: {channel: FRONTEND_MODELS_CHANNEL_NAME, params: this.params}
-    })
+    const tenant = await this._resolveEventTenant(id)
 
     // Always enter `runWithTenant`, even when no tenant resolved. Broadcast fan-out
     // runs in the publisher's ambient tenant context; falling back to `callback()`