velocious 1.0.451 → 1.0.453

package/build/frontend-model-controller.js

@@ -2,8 +2,10 @@
 
 import * as inflection from "inflection"
 import Controller from "./controller.js"
+import FrontendModelBaseResource from "./frontend-model-resource/base-resource.js"
 import Response from "./http-server/client/response.js"
-import {frontendModelResourceClassFromDefinition, frontendModelResourceConfigurationFromDefinition, frontendModelResourcePath, frontendModelResourcesForBackendProject} from "./frontend-models/resource-definition.js"
+import {frontendModelResourcesWithBuiltInsForBackendProject} from "./frontend-models/built-in-resources.js"
+import {frontendModelResourceClassFromDefinition, frontendModelResourceConfigurationFromDefinition, frontendModelResourcePath} from "./frontend-models/resource-definition.js"
 import {normalizeGroup as normalizeQueryGroup, normalizeJoins as normalizeQueryJoins, normalizePluck as normalizeQueryPluck, normalizePreload as normalizeQueryPreload, normalizeSearchOperator as normalizeQuerySearchOperator, normalizeSort as normalizeQuerySort} from "./frontend-models/query.js"
 import {assignSafeProperty, deserializeFrontendModelTransportValue, isBackendModelInstance, serializeFrontendModelTransportValue} from "./frontend-models/transport-serialization.js"
 import RoutesResolver from "./routes/resolver.js"
@@ -139,6 +141,14 @@ function normalizeFrontendModelSelect(select, rootModelName = null) {
  * @property {number | null} perPage - Page size.
  */
 
+/**
+ * @typedef {import("./configuration-types.js").ClientErrorPayloadContext & {
+ *   action: string,
+ *   expectedError: boolean,
+ *   frontendModelEndpoint: true
+ * }} FrontendModelEndpointErrorContext
+ */
+
 const frontendModelJoinedPathsSymbol = Symbol("frontendModelJoinedPaths")
 const frontendModelGroupedColumnsSymbol = Symbol("frontendModelGroupedColumns")
 const frontendModelWhereNoMatchSymbol = Symbol("frontendModelWhereNoMatch")
@@ -184,32 +194,69 @@ function frontendModelValidationErrorForError(error) {
  * developer for the frontend" — the framework treats it as
  * user-facing: surface the message, forward the metadata, and skip
  * the noisy endpoint-error log.
- * @param {?} error - Caught error.
- * @returns {boolean}
+ * @param {unknown} error - Caught error.
+ * @returns {boolean} Whether the error has Velocious frontend metadata.
  */
 function frontendModelErrorHasVelociousMetadata(error) {
-  return Boolean(error && typeof error === "object" && /**
-                                                        * Types the following value.
-                                                        * @type {?} */ (error).velocious && typeof /**
-                                                                                                   * Types the following value.
-                                                                                                   * @type {?} */ (error).velocious === "object")
+  if (!error || typeof error !== "object") return false
+
+  // Runtime checks above narrow this caught value to the metadata record shape.
+  const errorRecord = /** @type {{velocious?: import("./configuration-types.js").ClientErrorPayloadReporterPayload}} */ (error)
+
+  return isPlainObject(errorRecord.velocious)
+}
+
+/**
+ * Whether the error has a frontend-model error type marker.
+ * @param {unknown} error - Caught error.
+ * @returns {boolean} Whether the error has an error type.
+ */
+function frontendModelErrorHasErrorType(error) {
+  if (!error || typeof error !== "object") return false
+
+  // Runtime checks above narrow this caught value to the marker record shape.
+  const errorRecord = /** @type {{errorType?: string}} */ (error)
+
+  return typeof errorRecord.errorType === "string" && errorRecord.errorType.length > 0
+}
+
+/**
+ * Whether the error is an expected frontend-model user-flow failure.
+ * @param {unknown} error - Caught error.
+ * @returns {boolean} Whether the error is expected.
+ */
+function frontendModelExpectedError(error) {
+  if (error instanceof ValidationError) return true
+  if (error instanceof VelociousError && error.safeToExpose) return true
+  if (frontendModelErrorHasVelociousMetadata(error)) return true
+
+  return frontendModelErrorHasErrorType(error)
 }
 
 /**
  * Runs frontend model velocious metadata for error.
- * @param {?} error - Caught error.
- * @returns {Record<string, ?> | null}
+ * @param {unknown} error - Caught error.
+ * @returns {import("./configuration-types.js").ClientErrorPayloadReporterPayload | null} Frontend-model Velocious metadata when present.
  */
 function frontendModelVelociousMetadataForError(error) {
-  if (!frontendModelErrorHasVelociousMetadata(error)) return null
-  return /** @type {Record<string, ?>} */ (/**
-                                            * Types the following value.
-                                            * @type {?} */ (error).velocious)
+  const errorCode = error instanceof VelociousError && error.safeToExpose && typeof error.code === "string" && error.code.length > 0
+    ? error.code
+    : null
+
+  if (!frontendModelErrorHasVelociousMetadata(error)) {
+    return errorCode ? {code: errorCode} : null
+  }
+
+  // frontendModelErrorHasVelociousMetadata guards the caught value before this cast.
+  const errorRecord = /** @type {{velocious: import("./configuration-types.js").ClientErrorPayloadReporterPayload}} */ (error)
+  const metadata = errorRecord.velocious
+
+  return errorCode ? {...metadata, code: errorCode} : metadata
 }
 
 /**
  * Runs frontend model client message for error.
- * @param {?} error - Caught error.
+ * @param {unknown} error - Caught error.
  * @returns {string} - Message safe to return to API clients.
  */
 function frontendModelClientMessageForError(error) {
@@ -237,8 +284,8 @@ function frontendModelClientMessageForError(error) {
  * @param {object} args - Arguments.
  * @param {import("./configuration.js").default} args.configuration - Current configuration.
  * @param {string} args.environment - Current environment.
- * @param {?} args.error - Caught error.
- * @returns {Record<string, ?>} - Optional debug payload for non-production environments.
+ * @param {unknown} args.error - Caught error.
+ * @returns {import("./configuration-types.js").ClientErrorPayloadReporterPayload} - Optional debug payload for non-production environments.
  */
 function frontendModelDebugPayloadForError({configuration, environment, error}) {
   const debugAllowed = frontendModelDebugErrorEnvironments.has(environment) || environment !== "production" && configuration.getExposeInternalErrorsToClients()
@@ -634,7 +681,7 @@ export default class FrontendModelController extends Controller {
     const backendProjects = this.getConfiguration().getBackendProjects()
 
     for (const backendProject of backendProjects) {
-      const resources = frontendModelResourcesForBackendProject(backendProject)
+      const resources = frontendModelResourcesWithBuiltInsForBackendProject(backendProject)
 
       if (modelName && modelName.length > 0 && resources[modelName]) {
         const resourceDefinition = resources[modelName]
@@ -688,7 +735,7 @@ export default class FrontendModelController extends Controller {
    * @returns {{backendProject: import("./configuration-types.js").BackendProjectConfiguration, modelName: string, resourceClass: import("./configuration-types.js").FrontendModelResourceClassType, resourceConfiguration: import("./configuration-types.js").NormalizedFrontendModelResourceConfiguration} | null} - Frontend model resource configuration for model name.
    */
   frontendModelResourceConfigurationForBackendProjectModelName({backendProject, modelName}) {
-    const resources = frontendModelResourcesForBackendProject(backendProject)
+    const resources = frontendModelResourcesWithBuiltInsForBackendProject(backendProject)
     const resourceDefinition = resources[modelName]
 
     if (!resourceDefinition) return null
@@ -982,16 +1029,31 @@ export default class FrontendModelController extends Controller {
   }
 
   /**
-   * Runs frontend model authorized query.
+   * Runs frontend model ability authorized query.
    * @param {"index" | "find" | "create" | "update" | "destroy" | "attach" | "download" | "url"} action - Frontend action.
    * @returns {import("./database/query/model-class-query.js").default<typeof import("./database/record/index.js").default>} - Authorized query for the action.
    */
-  frontendModelAuthorizedQuery(action) {
+  frontendModelAbilityAuthorizedQuery(action) {
     const abilityAction = this.frontendModelAbilityAction(action)
 
     return this.frontendModelClass().accessibleFor(abilityAction, this.currentAbility())
   }
 
+  /**
+   * Runs frontend model authorized query.
+   * @param {"index" | "find" | "create" | "update" | "destroy" | "attach" | "download" | "url"} action - Frontend action.
+   * @returns {import("./database/query/model-class-query.js").default<typeof import("./database/record/index.js").default>} - Authorized query for the action.
+   */
+  frontendModelAuthorizedQuery(action) {
+    const resource = this.frontendModelResourceInstance()
+
+    if (resource.authorizedQuery !== FrontendModelBaseResource.prototype.authorizedQuery) {
+      return resource.authorizedQuery(action)
+    }
+
+    return this.frontendModelAbilityAuthorizedQuery(action)
+  }
+
   /**
    * Runs frontend model primary key value.
    * @param {import("./database/record/index.js").default} model - Model instance.
@@ -1593,7 +1655,11 @@ export default class FrontendModelController extends Controller {
         modelClass,
         path: pluckEntry.path
       })
-      const columnName = this.resolveFrontendModelColumnName(targetModelClass, pluckEntry.column)
+      const columnName = this.resolveFrontendModelQueryableColumnName({
+        attributeName: pluckEntry.column,
+        modelClass: targetModelClass,
+        operationName: "pluck"
+      })
 
       if (!columnName) {
         throw new Error(`Unknown pluck column "${pluckEntry.column}" for ${targetModelClass.name}`)
@@ -1672,7 +1738,11 @@ export default class FrontendModelController extends Controller {
       modelClass,
       path: search.path
     })
-    const columnName = this.resolveFrontendModelColumnName(targetModelClass, search.column)
+    const columnName = this.resolveFrontendModelQueryableColumnName({
+      attributeName: search.column,
+      modelClass: targetModelClass,
+      operationName: "search"
+    })
 
     if (!columnName) {
       throw new Error(`Unknown search column "${search.column}" for ${targetModelClass.name}`)
@@ -1850,6 +1920,110 @@ export default class FrontendModelController extends Controller {
     }
   }
 
+  /**
+   * Runs frontend model exposed attribute names for model class.
+   * @param {typeof import("./database/record/index.js").default} modelClass - Model class.
+   * @returns {Set<string> | null} - Exposed attribute names, or null when no resource metadata is available.
+   */
+  frontendModelExposedAttributeNamesForModelClass(modelClass) {
+    const frontendModelResource = this.frontendModelResourceConfigurationForModelClass(modelClass)
+    const attributes = frontendModelResource?.resourceConfiguration.attributes
+
+    if (!attributes) return null
+
+    if (Array.isArray(attributes)) {
+      const attributeNames = attributes
+        .map((entry) => {
+          if (typeof entry === "string") return entry
+          if (!entry || typeof entry !== "object") return null
+
+          const name = /**
+                        * Types the following value.
+                        * @type {Record<string, ?>} */ (entry).name
+
+          return typeof name === "string" && name.length > 0 ? name : null
+        })
+        .filter((entry) => typeof entry === "string")
+
+      return new Set(attributeNames)
+    }
+
+    if (typeof attributes === "object") {
+      return new Set(Object.keys(attributes))
+    }
+
+    return null
+  }
+
+  /**
+   * Resolves a frontend-supplied key to its canonical model attribute name.
+   * @param {typeof import("./database/record/index.js").default} modelClass - Model class.
+   * @param {string} key - Frontend key or raw column key.
+   * @returns {string | null} - Canonical attribute name.
+   */
+  frontendModelAttributeNameForKey(modelClass, key) {
+    const resolvedAttributeName = modelClass.resolveAttributeName(key)
+
+    if (resolvedAttributeName) return resolvedAttributeName
+
+    const columnAttributeName = modelClass.getColumnNameToAttributeNameMap()[key]
+
+    return columnAttributeName || null
+  }
+
+  /**
+   * Checks if a frontend-supplied attribute is exposed by the resource.
+   * @param {object} args - Args.
+   * @param {string} args.attributeName - Requested attribute name.
+   * @param {typeof import("./database/record/index.js").default} args.modelClass - Model class.
+   * @returns {boolean} - Whether the resource permits the attribute.
+   */
+  frontendModelAttributeIsExposed({attributeName, modelClass}) {
+    const exposedAttributeNames = this.frontendModelExposedAttributeNamesForModelClass(modelClass)
+
+    if (!exposedAttributeNames) return true
+
+    return exposedAttributeNames.has(attributeName)
+  }
+
+  /**
+   * Validates a selected frontend-model attribute list against resource metadata.
+   * @param {object} args - Args.
+   * @param {string[]} args.attributeNames - Selected attribute names.
+   * @param {typeof import("./database/record/index.js").default} args.modelClass - Model class.
+   * @param {"select" | "selectsExtra"} args.operationName - Selection operation.
+   * @returns {string[]} - Validated selected attribute names.
+   */
+  validateFrontendModelSelectedAttributes({attributeNames, modelClass, operationName}) {
+    for (const attributeName of attributeNames) {
+      if (this.frontendModelAttributeIsExposed({attributeName, modelClass})) continue
+
+      throw new Error(`Unknown ${operationName} attribute "${attributeName}" for ${modelClass.name}`)
+    }
+
+    return attributeNames
+  }
+
+  /**
+   * Resolves a user-queryable frontend attribute to a database column.
+   * @param {object} args - Args.
+   * @param {string} args.attributeName - Requested attribute name.
+   * @param {typeof import("./database/record/index.js").default} args.modelClass - Model class.
+   * @param {"group" | "pluck" | "search" | "sort" | "where"} args.operationName - Query operation.
+   * @returns {string | undefined} - Resolved column name.
+   */
+  resolveFrontendModelQueryableColumnName({attributeName, modelClass, operationName}) {
+    void operationName
+
+    const resolvedAttributeName = this.frontendModelAttributeNameForKey(modelClass, attributeName)
+
+    if (resolvedAttributeName && !this.frontendModelAttributeIsExposed({attributeName: resolvedAttributeName, modelClass})) {
+      return undefined
+    }
+
+    return this.resolveFrontendModelColumnName(modelClass, attributeName)
+  }
+
   /**
    * Resolves a key that may be either a camelCase attribute name or a raw DB
    * column name to its canonical column name.  Returns `undefined` when the
@@ -1880,7 +2054,11 @@ export default class FrontendModelController extends Controller {
    */
   applyFrontendModelWhereForPath({modelClass, path, query, where}) {
     for (const [attributeName, value] of Object.entries(where)) {
-      const columnName = this.resolveFrontendModelColumnName(modelClass, attributeName)
+      const columnName = this.resolveFrontendModelQueryableColumnName({
+        attributeName,
+        modelClass,
+        operationName: "where"
+      })
 
       if (columnName) {
         this.ensureFrontendModelJoinPath({path, query})
@@ -2004,7 +2182,11 @@ export default class FrontendModelController extends Controller {
       modelClass,
       path: group.path
     })
-    const columnName = this.resolveFrontendModelColumnName(targetModelClass, group.column)
+    const columnName = this.resolveFrontendModelQueryableColumnName({
+      attributeName: group.column,
+      modelClass: targetModelClass,
+      operationName: "group"
+    })
 
     if (!columnName) {
       throw new Error(`Unknown group column "${group.column}" for ${targetModelClass.name}`)
@@ -2117,7 +2299,11 @@ export default class FrontendModelController extends Controller {
     const translatedAttributeNames = Object.keys(translatedAttributesMap)
     const isTranslatedSortAttribute = translatedAttributeNames.includes(sort.column)
 
-    const columnName = this.resolveFrontendModelColumnName(targetModelClass, sort.column)
+    const columnName = this.resolveFrontendModelQueryableColumnName({
+      attributeName: sort.column,
+      modelClass: targetModelClass,
+      operationName: "sort"
+    })
     const direction = sort.direction.toUpperCase()
 
     if (isTranslatedSortAttribute) {
@@ -2194,7 +2380,15 @@ export default class FrontendModelController extends Controller {
 
     if (!select) return null
 
-    return select[modelClass.getModelName()] || null
+    const selectedAttributes = select[modelClass.getModelName()] || null
+
+    if (!selectedAttributes) return null
+
+    return this.validateFrontendModelSelectedAttributes({
+      attributeNames: selectedAttributes,
+      modelClass,
+      operationName: "select"
+    })
   }
 
   /**
@@ -2207,7 +2401,15 @@ export default class FrontendModelController extends Controller {
 
     if (!selectsExtra) return null
 
-    return selectsExtra[modelClass.getModelName()] || null
+    const extraAttributes = selectsExtra[modelClass.getModelName()] || null
+
+    if (!extraAttributes) return null
+
+    return this.validateFrontendModelSelectedAttributes({
+      attributeNames: extraAttributes,
+      modelClass,
+      operationName: "selectsExtra"
+    })
   }
 
   /**
@@ -2274,42 +2476,6 @@ export default class FrontendModelController extends Controller {
     return null
   }
 
-  /**
-   * Runs frontend model non default attributes for model class.
-   * @param {typeof import("./database/record/index.js").default} modelClass - Model class.
-   * @returns {string[]} - Attribute names explicitly marked selectedByDefault: false.
-   */
-  frontendModelNonDefaultAttributesForModelClass(modelClass) {
-    const frontendModelResource = this.frontendModelResourceConfigurationForModelClass(modelClass)
-    const attributes = frontendModelResource?.resourceConfiguration.attributes
-
-    if (!attributes) return []
-
-    if (Array.isArray(attributes)) {
-      return attributes
-        .filter((entry) => {
-          if (typeof entry !== "object" || !entry) return false
-
-          return /** @type {Record<string, ?>} */ (entry).selectedByDefault === false
-        })
-        .map((entry) => /**
-                         * Types the following value.
-                         * @type {Record<string, ?>} */ (/**
-                                                         * Types the following value.
-                                                         * @type {?} */ (entry)).name)
-    }
-
-    if (typeof attributes === "object") {
-      return Object.entries(attributes)
-        .filter(([, config]) => typeof config === "object" && config && /**
-                                                                         * Types the following value.
-                                                                         * @type {Record<string, ?>} */ (config).selectedByDefault === false)
-        .map(([name]) => name)
-    }
-
-    return []
-  }
-
   /**
    * Runs serialize frontend model attributes.
    * @param {import("./database/record/index.js").default} model - Model instance.
@@ -2407,12 +2573,10 @@ export default class FrontendModelController extends Controller {
         return modelAttributes
       }
 
-      const excludedAttributes = this.frontendModelNonDefaultAttributesForModelClass(modelClass)
-      const serializedAttributes = {...modelAttributes}
-
-      for (const excludedName of excludedAttributes) {
-        delete serializedAttributes[excludedName]
-      }
+      /**
+       * Serialized attributes.
+       * @type {Record<string, ?>} */
+      const serializedAttributes = {}
 
       for (const attributeName of defaultAttributes) {
         if (!attributeExists(attributeName)) continue
@@ -2454,7 +2618,7 @@ export default class FrontendModelController extends Controller {
                             * @type {typeof import("./database/record/index.js").default} */ (model.constructor).getModelName()
 
     for (const backendProject of backendProjects) {
-      const resources = frontendModelResourcesForBackendProject(backendProject)
+      const resources = frontendModelResourcesWithBuiltInsForBackendProject(backendProject)
       const resourceDefinition = resources[modelClassName]
       const resourceClass = resourceDefinition ? frontendModelResourceClassFromDefinition(resourceDefinition) : null
 
@@ -2775,12 +2939,43 @@ export default class FrontendModelController extends Controller {
     return this.frontendModelErrorPayload(frontendModelClientSafeErrorMessage)
   }
 
+  /**
+   * Builds frontend-model endpoint error context for logging and client payload reporters.
+   * @param {object} args - Error context args.
+   * @param {string} args.action - Endpoint/action label.
+   * @param {unknown} args.error - Caught error.
+   * @param {"index" | "find" | "create" | "update" | "destroy" | "attach" | "download" | "url" | "custom-command"} [args.commandType] - Frontend-model command type.
+   * @param {string | undefined} [args.model] - Request model name when available.
+   * @param {string | undefined} [args.requestId] - Batch request id when available.
+   * @returns {FrontendModelEndpointErrorContext} Frontend-model endpoint error context.
+   */
+  frontendModelEndpointErrorContext({action, commandType, error, model, requestId}) {
+    let resolvedModel = model
+
+    if (!resolvedModel) {
+      const cachedParams = this._frontendModelParamsOverride || this._frontendModelParams
+      const paramsModel = cachedParams ? cachedParams.model : undefined
+      resolvedModel = typeof paramsModel === "string" && paramsModel.length > 0 ? paramsModel : undefined
+    }
+
+    return {
+      action,
+      commandType,
+      controller: this.constructor.name,
+      expectedError: frontendModelExpectedError(error),
+      frontendModelEndpoint: true,
+      model: resolvedModel,
+      requestId
+    }
+  }
+
   /**
    * Runs frontend model client error payload for error.
-   * @param {?} error - Caught error.
-   * @returns {Promise<Record<string, ?>>} - Client payload for the current environment.
+   * @param {unknown} error - Caught error.
+   * @param {FrontendModelEndpointErrorContext | undefined} [endpointErrorContext] - Frontend-model endpoint error context.
+   * @returns {Promise<import("./configuration-types.js").ClientErrorPayloadReporterPayload>} - Client payload for the current environment.
    */
-  async frontendModelClientErrorPayloadForError(error) {
+  async frontendModelClientErrorPayloadForError(error, endpointErrorContext) {
     const velociousMetadata = frontendModelVelociousMetadataForError(error)
     const normalizedError = error instanceof Error ? error : new Error(String(error))
 
@@ -2818,9 +3013,7 @@ export default class FrontendModelController extends Controller {
       ...(velociousMetadata ? {velocious: velociousMetadata} : {}),
       ...validationErrorsPayload,
       ...(await this.getConfiguration().clientErrorPayloadForError({
-        context: {
-          controller: this.constructor.name
-        },
+        context: endpointErrorContext || {controller: this.constructor.name},
         error: normalizedError,
         request: this.getRequest()
       }))
@@ -2838,23 +3031,12 @@ export default class FrontendModelController extends Controller {
    * @returns {Promise<void>} - Resolves after logging.
    */
   async frontendModelLogEndpointError({action, error, commandType, model, requestId}) {
-    // Errors annotated with `error.velocious = {...}` are user-flow
-    // failures the developer has marked as expected (bad password,
-    // validation message, etc.). Surface the message + metadata to
-    // the client (handled by frontendModelClientErrorPayloadForError),
-    // but skip the error log so monitoring stays focused on real
-    // backend failures.
-    if (frontendModelErrorHasVelociousMetadata(error)) return
+    const errorContext = this.frontendModelEndpointErrorContext({action, commandType, error, model, requestId})
 
-    let resolvedModel = model
-
-    if (!resolvedModel) {
-      try {
-        resolvedModel = this.frontendModelParams().model
-      } catch {
-        resolvedModel = undefined
-      }
-    }
+    // Expected user-flow errors are surfaced to clients by
+    // frontendModelClientErrorPayloadForError, but skipped here so monitoring
+    // stays focused on real backend failures.
+    if (errorContext.expectedError) return
 
     const errorMessage = error instanceof Error
       ? `${error.message}\n${error.stack || ""}`
@@ -2864,27 +3046,22 @@ export default class FrontendModelController extends Controller {
       action,
       commandType,
       error: errorMessage,
-      model: resolvedModel,
+      model: errorContext.model,
       requestId
     }])
 
     // Surface genuinely unexpected backend failures on the framework-error
     // channel so process-level bug reporters capture them, instead of the
     // controller silently swallowing them behind the generic "Request
-    // failed." client message. Developer-annotated user-flow errors
-    // (`error.velocious` metadata — handled by the early return above),
-    // validation errors, and deliberately client-safe VelociousErrors are
-    // expected and must NOT be reported as framework errors.
-    if (!(error instanceof ValidationError) && !(error instanceof VelociousError && error.safeToExpose)) {
-      const errorPayload = {
-        context: {action, commandType, frontendModelEndpoint: true, model: resolvedModel, requestId},
-        error: error instanceof Error ? error : new Error(String(error)),
-        request: this.getRequest()
-      }
-
-      this.getConfiguration().getErrorEvents().emit("framework-error", errorPayload)
-      this.getConfiguration().getErrorEvents().emit("all-error", {...errorPayload, errorType: "framework-error"})
+    // failed." client message.
+    const errorPayload = {
+      context: errorContext,
+      error: error instanceof Error ? error : new Error(String(error)),
+      request: this.getRequest()
     }
+
+    this.getConfiguration().getErrorEvents().emit("framework-error", errorPayload)
+    this.getConfiguration().getErrorEvents().emit("all-error", {...errorPayload, errorType: "framework-error"})
   }
 
   /**
@@ -2903,12 +3080,14 @@ export default class FrontendModelController extends Controller {
                * @type {Record<string, ?>} */ (serializeFrontendModelTransportValue(responsePayload))
       })
     } catch (error) {
-      await this.frontendModelLogEndpointError({action, commandType: action, error})
+      const errorContext = this.frontendModelEndpointErrorContext({action, commandType: action, error})
+
+      await this.frontendModelLogEndpointError({action, commandType: action, error, model: errorContext.model})
 
       await this.render({
         json: /**
                * Types the following value.
-               * @type {Record<string, ?>} */ (serializeFrontendModelTransportValue(await this.frontendModelClientErrorPayloadForError(error)))
+               * @type {Record<string, ?>} */ (serializeFrontendModelTransportValue(await this.frontendModelClientErrorPayloadForError(error, errorContext)))
       })
     }
   }
@@ -3183,7 +3362,7 @@ export default class FrontendModelController extends Controller {
           response: responsePayload || this.frontendModelErrorPayload("Action halted by beforeAction.")
         })
       } catch (error) {
-        await this.frontendModelLogEndpointError({
+        const errorContext = this.frontendModelEndpointErrorContext({
           action: "frontendApi",
           commandType,
           error,
@@ -3191,9 +3370,17 @@ export default class FrontendModelController extends Controller {
           requestId
         })
 
+        await this.frontendModelLogEndpointError({
+          action: errorContext.action,
+          commandType: errorContext.commandType,
+          error,
+          model: errorContext.model,
+          requestId: errorContext.requestId
+        })
+
         responses.push({
           requestId,
-          response: await this.frontendModelClientErrorPayloadForError(error)
+          response: await this.frontendModelClientErrorPayloadForError(error, errorContext)
         })
       }
     }
@@ -3414,12 +3601,14 @@ export default class FrontendModelController extends Controller {
                * @type {Record<string, ?>} */ (serializeFrontendModelTransportValue(responsePayload))
       })
     } catch (error) {
-      await this.frontendModelLogEndpointError({action: "frontendCustomCommand", commandType: "custom-command", error})
+      const errorContext = this.frontendModelEndpointErrorContext({action: "frontendCustomCommand", commandType: "custom-command", error})
+
+      await this.frontendModelLogEndpointError({action: errorContext.action, commandType: errorContext.commandType, error, model: errorContext.model})
 
       await this.render({
         json: /**
                * Types the following value.
-               * @type {Record<string, ?>} */ (serializeFrontendModelTransportValue(await this.frontendModelClientErrorPayloadForError(error)))
+               * @type {Record<string, ?>} */ (serializeFrontendModelTransportValue(await this.frontendModelClientErrorPayloadForError(error, errorContext)))
       })
     }
   }

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

@@ -14,6 +14,7 @@ import isPlainObject from "../utils/plain-object.js"
  * @typedef {import("../controller.js").default & {
  *   currentAbility: () => import("../authorization/ability.js").default | undefined,
  *   frontendModelAbilityAction: (action: FrontendModelResourceAction) => string,
+ *   frontendModelAbilityAuthorizedQuery: (action: FrontendModelResourceAction) => import("../database/query/model-class-query.js").default<typeof import("../database/record/index.js").default>,
  *   frontendModelAuthorizedQuery: (action: FrontendModelResourceAction) => import("../database/query/model-class-query.js").default<typeof import("../database/record/index.js").default>,
  *   frontendModelIndexQuery: () => import("../database/query/model-class-query.js").default<typeof import("../database/record/index.js").default>,
  *   frontendModelParams: () => import("../configuration-types.js").VelociousParams,
@@ -393,7 +394,7 @@ export default class FrontendModelBaseResource extends AuthorizationBaseResource
    */
   authorizedQuery(action) {
     // Narrows the controller query to this resource's model class.
-    return /** @type {import("../database/query/model-class-query.js").default<TModelClass>} */ (this.typedControllerInstance().frontendModelAuthorizedQuery(action))
+    return /** @type {import("../database/query/model-class-query.js").default<TModelClass>} */ (this.typedControllerInstance().frontendModelAbilityAuthorizedQuery(action))
   }