velocious 1.0.468 → 1.0.470

package/README.md

@@ -378,7 +378,7 @@ export default new Configuration({
 `frontendModels` entries must be `FrontendModelBaseResource` subclasses. Built-in CRUD/find/index/serialize behavior lives in the base class, and app resources override only the pieces they actually need.
 Resource-level index customization should prefer `indexQuery()` or the pagination/search/sort hooks over replacing `records()`, so built-in pluck and aggregate count support can keep using the same query. See [`docs/frontend-model-resources.md`](docs/frontend-model-resources.md) for the resource extension points.
 
-Custom class- and instance-level commands are declared via `collectionCommands` / `memberCommands`. Each entry is a plain camelCase method name, or a `{name, args?, returnType?}` object that types the command's arguments and response — e.g. `memberCommands: ["suspend", {name: "refresh", args: [{name: "age", type: "number"}], returnType: "string"}]`. See [`docs/frontend-model-resources.md#custom-commands`](docs/frontend-model-resources.md#custom-commands).
+Custom class- and instance-level commands are declared via `collectionCommands` / `memberCommands`. Each entry is a plain camelCase method name, or a `{name, args?, returnType?}` object that types the command's arguments and response — e.g. `memberCommands: ["suspend", {name: "refresh", args: [{name: "age", type: "number"}], returnType: "string"}]`. A command whose args are a single object literal with only optional fields generates an omittable parameter (`record.command()` works without passing `{}`); any required field keeps the argument mandatory. See [`docs/frontend-model-resources.md#custom-commands`](docs/frontend-model-resources.md#custom-commands).
 
 Resources expose the full CRUD ability set (`create`, `destroy`, `read`, `update`) by default. To restrict the API surface — for example to a read-only resource — declare an explicit subset:
 
@@ -591,16 +591,18 @@ const configuration = new Configuration({
 
 This opt-in is ignored in `production`; production frontend-model responses never include internal exception details.
 
-Backends can append client-safe metadata to frontend-model error responses with `configuration.addClientErrorPayloadReporter(...)`. Reporters receive the caught `error`, the current `request`, and a small `context` object, and should only return fields that are safe for clients to see. Frontend-model endpoint failures include `context.frontendModelEndpoint`, `action`, `commandType`, `model`, `requestId`, and `expectedError`. This is useful for attaching an error-reporting URL while keeping the normal production error message generic:
+Backends can append client-safe metadata to frontend-model error responses with `configuration.addClientErrorPayloadReporter(...)`. Reporters receive the caught `error`, the current `request`, a safe `requestDetails` snapshot, and a small `context` object, and should only return fields that are safe for clients to see. Frontend-model endpoint failures include `context.frontendModelEndpoint`, `action`, `commandType`, `model`, `requestId`, and `expectedError`. This is useful for attaching an error-reporting URL while keeping the normal production error message generic:
 
 ```js
-configuration.addClientErrorPayloadReporter(async ({error, request, context}) => {
-  const report = await reportErrorToService({error, request, context})
+configuration.addClientErrorPayloadReporter(async ({error, requestDetails, context}) => {
+  const report = await reportErrorToService({error, requestDetails, context})
 
   return {bugReportUrl: report.url}
 })
 ```
 
+`requestDetails` includes `httpMethod`, `path`, and a parsed `body` snapshot when available. The body snapshot redacts common secret keys, truncates large strings and arrays, summarizes uploaded files and buffers without bytes, and compacts oversized frontend-model batches while preserving `requestId`, `model`, `commandType` / `customPath`, and payload shape.
+
 For sqlite web databases, Velocious defaults to `https://sql.js.org/dist/<file>` for `sql.js` wasm loading. You can override wasm resolution per database config with `locateFile`:
 
 ```js

package/build/configuration-types.js

@@ -212,6 +212,13 @@
  * @typedef {Record<string, import("./frontend-models/query.js").FrontendModelTransportValue>} ClientErrorPayloadReporterPayload
  */
 
+/**
+ * @typedef {object} ErrorRequestDetails
+ * @property {?} [body] - Sanitized parsed request body, when available.
+ * @property {string} httpMethod - Request HTTP method.
+ * @property {string} path - Request path.
+ */
+
 /**
  * @typedef {object} ClientErrorPayloadContext
  * @property {string} controller - Controller class name.
@@ -227,7 +234,8 @@
  * @typedef {function({
  *   context: ClientErrorPayloadContext,
  *   error: Error,
- *   request: import("./http-server/client/request.js").default | import("./http-server/client/websocket-request.js").default | undefined
+ *   request: import("./http-server/client/request.js").default | import("./http-server/client/websocket-request.js").default | undefined,
+ *   requestDetails: ErrorRequestDetails | null
  * }): Promise<ClientErrorPayloadReporterPayload | void> | ClientErrorPayloadReporterPayload | void} ClientErrorPayloadReporterType
  */
 

package/build/configuration.js

@@ -18,6 +18,7 @@ import Ability from "./authorization/ability.js"
 import EventEmitter from "./utils/event-emitter.js"
 import VelociousWebsocketChannelSubscribers from "./http-server/websocket-channel-subscribers.js"
 import {CurrentConfigurationNotSetError, currentConfiguration, setCurrentConfiguration} from "./current-configuration.js"
+import {requestDetails} from "./error-reporting/request-details.js"
 import {frontendModelResourceClassFromDefinition, frontendModelResourceConfigurationFromDefinition, frontendModelResourcesForBackendProject} from "./frontend-models/resource-definition.js"
 import PluginRoutes from "./routes/plugin-routes.js"
 import restArgsError from "./utils/rest-args-error.js"
@@ -2411,9 +2412,13 @@ export default class VelociousConfiguration {
   async clientErrorPayloadForError(args) {
     /** @type {import("./configuration-types.js").ClientErrorPayloadReporterPayload} */
     const payload = {}
+    const details = requestDetails(args.request)
 
     for (const reporter of this._clientErrorPayloadReporters) {
-      const reporterPayload = await reporter(args)
+      const reporterPayload = await reporter({
+        ...args,
+        requestDetails: details
+      })
 
       if (reporterPayload && typeof reporterPayload === "object") {
         Object.assign(payload, reporterPayload)

package/build/environment-handlers/node/cli/commands/generate/frontend-models.js

@@ -1474,10 +1474,15 @@ export default class DbGenerateFrontendModels extends BaseCommand {
 
     if (metadata.args.length > 0) {
       const parameterNames = metadata.args.map((arg) => arg.name)
+      // A single args object whose every field is optional accepts `{}`, so default
+      // the parameter and mark it optional — callers can then omit it entirely
+      // (`record.command()` instead of `record.command({})`). Required-field args keep
+      // the mandatory parameter (a `{}` default wouldn't satisfy their type).
+      const defaultsToEmptyObject = metadata.args.length === 1 && this.argTypeAcceptsEmptyObject(metadata.args[0].type)
 
       return {
-        paramDocs: metadata.args.map((arg) => `   * @param {${arg.type}} ${arg.name} - Command argument.\n`).join(""),
-        parameters: parameterNames.join(", "),
+        paramDocs: metadata.args.map((arg) => `   * @param {${arg.type}} ${defaultsToEmptyObject ? `[${arg.name}]` : arg.name} - Command argument.\n`).join(""),
+        parameters: defaultsToEmptyObject ? `${parameterNames[0]} = {}` : parameterNames.join(", "),
         payloadArguments: `[${parameterNames.join(", ")}]`,
         returnType
       }
@@ -1491,6 +1496,124 @@ export default class DbGenerateFrontendModels extends BaseCommand {
     }
   }
 
+  /**
+   * Whether a single command-args JSDoc type is known to accept an empty object `{}`:
+   * a single balanced object literal whose top-level members are all optional (`name?:`)
+   * or index signatures (`[k: ...]:`). Anything else returns false so the parameter stays
+   * required — including a required member, a non-object-literal (a positional `number`,
+   * a `Record<...>` / `Partial<...>` whose key/wrapper may still require data), and any
+   * intersection/union (e.g. `{a?: x} & {b: string}`), where `{}` is not assignable.
+   * @param {string} type - The arg's JSDoc type string.
+   * @returns {boolean} - Whether the generated parameter can default to `{}`.
+   */
+  argTypeAcceptsEmptyObject(type) {
+    const trimmedType = type.trim()
+
+    // Must be a single balanced object literal: starts with `{`, ends with `}`, and the
+    // opening brace closes only at the final character. This rejects intersections/unions
+    // like `{a?: x} & {b: string}` that merely happen to start `{` and end `}`.
+    if (!(trimmedType.startsWith("{") && trimmedType.endsWith("}"))) return false
+    if (!this.isSingleBalancedObjectLiteral(trimmedType)) return false
+
+    const inner = trimmedType.slice(1, -1)
+
+    for (const member of this.splitTopLevelTypeMembers(inner)) {
+      const colonIndex = this.topLevelColonIndex(member)
+
+      // No top-level colon: a call/construct/mapped signature or malformed member —
+      // can't confirm it's optional, so treat the type as not empty-defaultable.
+      if (colonIndex < 0) return false
+
+      const key = member.slice(0, colonIndex).trim()
+
+      // Index signatures (`[k: string]`) don't require a value; optional props end in `?`.
+      // Anything else is a required property, so `{}` would not satisfy the type.
+      if (!key.startsWith("[") && !key.endsWith("?")) return false
+    }
+
+    return true
+  }
+
+  /**
+   * Splits the inner body of an object-literal type into its top-level members,
+   * respecting nested `{}` / `[]` / `<>` / `()` so field types like `string[] | null`
+   * or `{a: b}` aren't split mid-type. Members are separated by `,` or `;`.
+   * @param {string} inner - Object-literal body (without the outer braces).
+   * @returns {string[]} - Trimmed non-empty top-level members.
+   */
+  splitTopLevelTypeMembers(inner) {
+    const members = []
+    let depth = 0
+    let start = 0
+
+    for (let index = 0; index < inner.length; index += 1) {
+      const character = inner[index]
+
+      if (character === "{" || character === "[" || character === "<" || character === "(") {
+        depth += 1
+      } else if (character === "}" || character === "]" || character === ">" || character === ")") {
+        depth -= 1
+      } else if ((character === "," || character === ";") && depth === 0) {
+        members.push(inner.slice(start, index))
+        start = index + 1
+      }
+    }
+
+    members.push(inner.slice(start))
+
+    return members.map((member) => member.trim()).filter((member) => member.length > 0)
+  }
+
+  /**
+   * Index of the first top-level `:` in an object-literal member, ignoring colons
+   * nested inside `{}` / `[]` / `<>` / `()` (e.g. an index signature `[k: string]`).
+   * @param {string} member - A single object-literal member.
+   * @returns {number} - The colon index, or -1 when none is found at the top level.
+   */
+  topLevelColonIndex(member) {
+    let depth = 0
+
+    for (let index = 0; index < member.length; index += 1) {
+      const character = member[index]
+
+      if (character === "{" || character === "[" || character === "<" || character === "(") {
+        depth += 1
+      } else if (character === "}" || character === "]" || character === ">" || character === ")") {
+        depth -= 1
+      } else if (character === ":" && depth === 0) {
+        return index
+      }
+    }
+
+    return -1
+  }
+
+  /**
+   * Whether the type is a single balanced object literal — its leading `{` closes only
+   * at the final character. Rejects top-level intersections/unions like `{a?: x} & {b: y}`
+   * or `{a?: x} | string` whose brace depth returns to 0 before the end.
+   * @param {string} type - A trimmed type string that starts with `{` and ends with `}`.
+   * @returns {boolean} - Whether the braces wrap the whole type.
+   */
+  isSingleBalancedObjectLiteral(type) {
+    let depth = 0
+
+    for (let index = 0; index < type.length; index += 1) {
+      const character = type[index]
+
+      if (character === "{" || character === "[" || character === "<" || character === "(") {
+        depth += 1
+      } else if (character === "}" || character === "]" || character === ">" || character === ")") {
+        depth -= 1
+
+        // The opening brace balanced before the end, so something follows the literal.
+        if (depth === 0 && index < type.length - 1) return false
+      }
+    }
+
+    return depth === 0
+  }
+
   /**
    * Enriches custom-command metadata by deriving a command's typed args and return
    * type from the backend resource method's `@param`/`@returns` JSDoc when they are
@@ -1852,7 +1975,7 @@ export default class DbGenerateFrontendModels extends BaseCommand {
       throw new Error(`Could not parse JSDoc return type from: ${jsDocText}`)
     }
 
-    const returnType = jsDocText.slice(typeOpenIndex + 1, typeCloseIndex).trim()
+    const returnType = this.normalizeJsDocType(jsDocText.slice(typeOpenIndex + 1, typeCloseIndex))
 
     if (returnType.length < 1) {
       throw new Error(`Expected non-empty JSDoc return type in: ${jsDocText}`)
@@ -1861,6 +1984,18 @@ export default class DbGenerateFrontendModels extends BaseCommand {
     return returnType
   }
 
+  /**
+   * Collapses a JSDoc type spanning multiple comment lines into a single line so it can
+   * be emitted into an inline type-assertion cast. A multiline backend return type keeps
+   * its leading continuation asterisks in the captured substring, which are invalid inside
+   * an inline cast and make TypeScript read the asserted type as `undefined`.
+   * @param {string} jsDocType - Raw captured JSDoc type, possibly multiline.
+   * @returns {string} - Single-line JSDoc type.
+   */
+  normalizeJsDocType(jsDocType) {
+    return jsDocType.replace(/\s*\n\s*\*?[ \t]*/g, " ").trim()
+  }
+
   /**
    * Runs js doc parameters.
    * @param {string} jsDocText - JSDoc text inside comment markers.
@@ -1879,7 +2014,7 @@ export default class DbGenerateFrontendModels extends BaseCommand {
         throw new Error(`Could not parse JSDoc parameter type from: ${jsDocText}`)
       }
 
-      const type = jsDocText.slice(typeOpenIndex + 1, typeCloseIndex).trim()
+      const type = this.normalizeJsDocType(jsDocText.slice(typeOpenIndex + 1, typeCloseIndex))
 
       if (type.length < 1) {
         throw new Error(`Expected non-empty JSDoc parameter type in: ${jsDocText}`)

package/build/error-reporting/request-details.js

@@ -0,0 +1,308 @@
+// @ts-check
+
+import UploadedFile from "../http-server/client/uploaded-file/uploaded-file.js"
+
+const REQUEST_DETAILS_BODY_MAX_SERIALIZED_LENGTH = 12000
+const REQUEST_DETAILS_STRING_MAX_LENGTH = 1000
+const REQUEST_DETAILS_ARRAY_MAX_ITEMS = 50
+const REDACTED_REQUEST_DETAILS_VALUE = "[redacted]"
+
+/**
+ * Extracts request metadata without retaining the request object.
+ * @param {import("../http-server/client/request.js").default | import("../http-server/client/websocket-request.js").default | undefined} request - Request object, when present.
+ * @returns {import("../configuration-types.js").ErrorRequestDetails | null} - Request metadata.
+ */
+export function requestDetails(request) {
+  if (!request) return null
+
+  let details
+
+  try {
+    details = {
+      httpMethod: request.httpMethod(),
+      path: request.path()
+    }
+  } catch {
+    return null
+  }
+
+  const body = requestBodySnapshot(request)
+
+  if (body !== undefined) {
+    return {...details, body}
+  }
+
+  return details
+}
+
+/**
+ * Snapshots parsed request params for error reports.
+ * @param {import("../http-server/client/request.js").default | import("../http-server/client/websocket-request.js").default} request - Request object.
+ * @returns {? | undefined} - Sanitized body snapshot.
+ */
+function requestBodySnapshot(request) {
+  if (typeof request.params !== "function") return undefined
+
+  try {
+    return requestDetailsBodySnapshot(request.params())
+  } catch (error) {
+    return {
+      __unavailable: true,
+      error: error instanceof Error ? error.message : String(error)
+    }
+  }
+}
+
+/**
+ * Builds a bounded, redacted body snapshot for error reports.
+ * @param {?} body - Parsed request body.
+ * @returns {?} - Sanitized body snapshot.
+ */
+function requestDetailsBodySnapshot(body) {
+  const originalLength = serializedLength(body)
+  const sanitized = sanitizeRequestDetailsValue(body)
+  const sanitizedLength = serializedLength(sanitized)
+
+  if (originalLength <= REQUEST_DETAILS_BODY_MAX_SERIALIZED_LENGTH && sanitizedLength <= REQUEST_DETAILS_BODY_MAX_SERIALIZED_LENGTH) {
+    return sanitized
+  }
+
+  const compactFrontendModelBody = compactFrontendModelRequestBody(sanitized, originalLength)
+
+  if (serializedLength(compactFrontendModelBody) <= REQUEST_DETAILS_BODY_MAX_SERIALIZED_LENGTH) {
+    return compactFrontendModelBody
+  }
+
+  return compactRequestDetailsBody(sanitized, originalLength)
+}
+
+/**
+ * Sanitizes a value recursively for request details.
+ * @param {?} value - Value to sanitize.
+ * @param {string} [key] - Current object key.
+ * @param {WeakSet<object>} [seen] - Seen object references.
+ * @returns {?} - Sanitized value.
+ */
+function sanitizeRequestDetailsValue(value, key = "", seen = new WeakSet()) {
+  if (sensitiveRequestDetailsKey(key)) return REDACTED_REQUEST_DETAILS_VALUE
+  if (primitiveRequestDetailsValue(value)) return value
+  if (bufferValue(value)) return bufferRequestDetailsSummary(value)
+  if (value instanceof UploadedFile) return uploadedFileRequestDetailsSummary(value)
+  if (typeof value === "string") return sanitizeRequestDetailsString(value)
+  if (Array.isArray(value)) return sanitizeRequestDetailsArray(value, seen)
+  if (typeof value === "object") return sanitizeRequestDetailsObject(value, seen)
+
+  return String(value)
+}
+
+/**
+ * Checks whether a value can be kept as-is.
+ * @param {?} value - Value.
+ * @returns {boolean} - Whether the value is primitive and safe.
+ */
+function primitiveRequestDetailsValue(value) {
+  return value == null || typeof value === "boolean" || typeof value === "number"
+}
+
+/**
+ * Sanitizes a string value.
+ * @param {string} value - String value.
+ * @returns {string} - Sanitized string.
+ */
+function sanitizeRequestDetailsString(value) {
+  if (value.length <= REQUEST_DETAILS_STRING_MAX_LENGTH) return value
+
+  return `${value.slice(0, REQUEST_DETAILS_STRING_MAX_LENGTH)}... [truncated ${value.length - REQUEST_DETAILS_STRING_MAX_LENGTH} chars]`
+}
+
+/**
+ * Sanitizes an array value.
+ * @param {Array<?>} value - Array value.
+ * @param {WeakSet<object>} seen - Seen object references.
+ * @returns {Array<?>} - Sanitized array.
+ */
+function sanitizeRequestDetailsArray(value, seen) {
+  const entries = value
+    .slice(0, REQUEST_DETAILS_ARRAY_MAX_ITEMS)
+    .map((entry) => sanitizeRequestDetailsValue(entry, "", seen))
+
+  if (value.length > REQUEST_DETAILS_ARRAY_MAX_ITEMS) {
+    entries.push({__omittedItems: value.length - REQUEST_DETAILS_ARRAY_MAX_ITEMS})
+  }
+
+  return entries
+}
+
+/**
+ * Sanitizes a plain object-like value.
+ * @param {object} value - Object value.
+ * @param {WeakSet<object>} seen - Seen object references.
+ * @returns {Record<string, ?> | string} - Sanitized object or circular marker.
+ */
+function sanitizeRequestDetailsObject(value, seen) {
+  if (seen.has(value)) return "[circular]"
+
+  seen.add(value)
+
+  /** @type {Record<string, ?>} */
+  const sanitized = {}
+
+  for (const [entryKey, entryValue] of Object.entries(value)) {
+    sanitized[entryKey] = sanitizeRequestDetailsValue(entryValue, entryKey, seen)
+  }
+
+  seen.delete(value)
+
+  return sanitized
+}
+
+/**
+ * Checks whether a value is a Node.js Buffer.
+ * @param {?} value - Value.
+ * @returns {value is Buffer} - Whether value is a Buffer.
+ */
+function bufferValue(value) {
+  return typeof Buffer !== "undefined" && typeof Buffer.isBuffer === "function" && Buffer.isBuffer(value)
+}
+
+/**
+ * Summarizes raw binary data without serializing bytes.
+ * @param {Buffer} buffer - Uploaded or request buffer.
+ * @returns {Record<string, ?>} - Request-safe buffer summary.
+ */
+function bufferRequestDetailsSummary(buffer) {
+  return {
+    __redacted: true,
+    __type: "Buffer",
+    byteLength: buffer.byteLength
+  }
+}
+
+/**
+ * Summarizes uploaded files without serializing file bytes or temp paths.
+ * @param {UploadedFile} uploadedFile - Uploaded file object.
+ * @returns {Record<string, ?>} - Request-safe upload summary.
+ */
+function uploadedFileRequestDetailsSummary(uploadedFile) {
+  return {
+    __redacted: true,
+    __type: "UploadedFile",
+    contentType: uploadedFile.contentType() ?? null,
+    fieldName: uploadedFile.fieldName(),
+    filename: uploadedFile.filename(),
+    size: uploadedFile.size()
+  }
+}
+
+/**
+ * Checks whether a key should be redacted from request details.
+ * @param {string} key - Object key.
+ * @returns {boolean} - Whether the value is sensitive.
+ */
+function sensitiveRequestDetailsKey(key) {
+  return /authorization|contentBase64|password|secret|sessionToken|token/i.test(key)
+}
+
+/**
+ * Compacts a frontend-model request envelope while preserving debugging shape.
+ * @param {?} value - Sanitized body value.
+ * @param {number} originalSerializedLength - Byte count before redaction or compaction.
+ * @returns {?} - Compacted body value.
+ */
+function compactFrontendModelRequestBody(value, originalSerializedLength) {
+  if (!value || typeof value !== "object" || !Array.isArray(/** @type {Record<string, ?>} */ (value).requests)) {
+    return compactRequestDetailsBody(value, originalSerializedLength)
+  }
+
+  return {
+    __truncated: true,
+    originalSerializedLength,
+    requests: /** @type {Array<?>} */ (/** @type {Record<string, ?>} */ (value).requests).map((request) => {
+      return compactFrontendModelRequest(request)
+    })
+  }
+}
+
+/**
+ * Compacts one frontend-model request entry.
+ * @param {?} value - Candidate request entry from the transport envelope.
+ * @returns {?} - Compacted request.
+ */
+function compactFrontendModelRequest(value) {
+  if (!value || typeof value !== "object") return value
+
+  const request = /** @type {Record<string, ?>} */ (value)
+  /** @type {Record<string, ?>} */
+  const compact = {}
+
+  for (const key of ["requestId", "model", "commandType", "customPath"]) {
+    if (request[key] !== undefined) compact[key] = request[key]
+  }
+
+  if (request.payload !== undefined) {
+    compact.payload = compactFrontendModelPayload(request.payload)
+  }
+
+  return compact
+}
+
+/**
+ * Compacts a frontend-model payload.
+ * @param {?} value - Candidate payload from a request entry.
+ * @returns {?} - Compacted payload.
+ */
+function compactFrontendModelPayload(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return value
+
+  const payload = /** @type {Record<string, ?>} */ (value)
+  /** @type {Record<string, ?>} */
+  const compact = {}
+
+  for (const [key, entryValue] of Object.entries(payload)) {
+    compact[key] = compactFrontendModelPayloadEntry({key, value: entryValue})
+  }
+
+  return compact
+}
+
+/**
+ * Compacts one frontend-model payload entry.
+ * @param {{key: string, value: ?}} args - Payload entry.
+ * @returns {?} - Compacted value.
+ */
+function compactFrontendModelPayloadEntry({key, value}) {
+  if (key !== "attributes" || !value || typeof value !== "object" || Array.isArray(value)) {
+    return value
+  }
+
+  return {__keys: Object.keys(/** @type {Record<string, ?>} */ (value))}
+}
+
+/**
+ * Builds a last-resort compact body summary.
+ * @param {?} value - Sanitized body.
+ * @param {number} originalSerializedLength - Byte count before redaction or compaction.
+ * @returns {Record<string, ?>} - Compact summary.
+ */
+function compactRequestDetailsBody(value, originalSerializedLength) {
+  return {
+    __truncated: true,
+    originalSerializedLength,
+    topLevelKeys: value && typeof value === "object" && !Array.isArray(value)
+      ? Object.keys(/** @type {Record<string, ?>} */ (value))
+      : []
+  }
+}
+
+/**
+ * Measures JSON serialized length.
+ * @param {?} value - Value to measure.
+ * @returns {number} - Serialized length, or Infinity when not serializable.
+ */
+function serializedLength(value) {
+  try {
+    return JSON.stringify(value).length
+  } catch {
+    return Infinity
+  }
+}

package/build/frontend-model-controller.js

@@ -8,6 +8,7 @@ import {frontendModelResourcesWithBuiltInsForBackendProject} from "./frontend-mo
 import {frontendModelResourceClassFromDefinition, frontendModelResourceConfigurationFromDefinition, frontendModelResourcePath, frontendModelResourcesForBackendProject} from "./frontend-models/resource-definition.js"
 import {FrontendModelQueryError, 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 {requestDetails} from "./error-reporting/request-details.js"
 import RoutesResolver from "./routes/resolver.js"
 import {ValidationError} from "./database/record/index.js"
 import { normalizeDateStringForWrite } from "./database/datetime-storage.js"
@@ -3183,7 +3184,8 @@ export default class FrontendModelController extends Controller {
     const errorPayload = {
       context: errorContext,
       error: error instanceof Error ? error : new Error(String(error)),
-      request: this.getRequest()
+      request: this.getRequest(),
+      requestDetails: requestDetails(this.getRequest())
     }
 
     this.getConfiguration().getErrorEvents().emit("framework-error", errorPayload)

package/build/src/configuration-types.d.ts

@@ -186,6 +186,12 @@
 /**
  * @typedef {Record<string, import("./frontend-models/query.js").FrontendModelTransportValue>} ClientErrorPayloadReporterPayload
  */
+/**
+ * @typedef {object} ErrorRequestDetails
+ * @property {?} [body] - Sanitized parsed request body, when available.
+ * @property {string} httpMethod - Request HTTP method.
+ * @property {string} path - Request path.
+ */
 /**
  * @typedef {object} ClientErrorPayloadContext
  * @property {string} controller - Controller class name.
@@ -200,7 +206,8 @@
  * @typedef {function({
  *   context: ClientErrorPayloadContext,
  *   error: Error,
- *   request: import("./http-server/client/request.js").default | import("./http-server/client/websocket-request.js").default | undefined
+ *   request: import("./http-server/client/request.js").default | import("./http-server/client/websocket-request.js").default | undefined,
+ *   requestDetails: ErrorRequestDetails | null
  * }): Promise<ClientErrorPayloadReporterPayload | void> | ClientErrorPayloadReporterPayload | void} ClientErrorPayloadReporterType
  */
 /**
@@ -878,6 +885,20 @@ export type ScheduledBackgroundJobConfiguration = {
 };
 export type VelociousParams = Record<string, string>;
 export type ClientErrorPayloadReporterPayload = Record<string, import("./frontend-models/query.js").FrontendModelTransportValue>;
+export type ErrorRequestDetails = {
+    /**
+     * - Sanitized parsed request body, when available.
+     */
+    body?: unknown;
+    /**
+     * - Request HTTP method.
+     */
+    httpMethod: string;
+    /**
+     * - Request path.
+     */
+    path: string;
+};
 export type ClientErrorPayloadContext = {
     /**
      * - Controller class name.
@@ -912,6 +933,7 @@ export type ClientErrorPayloadReporterType = (arg0: {
     context: ClientErrorPayloadContext;
     error: Error;
     request: import("./http-server/client/request.js").default | import("./http-server/client/websocket-request.js").default | undefined;
+    requestDetails: ErrorRequestDetails | null;
 }) => Promise<ClientErrorPayloadReporterPayload | void> | ClientErrorPayloadReporterPayload | void;
 export type VelociousLooseObject = Record<string, unknown> & {
     configuration?: import("./configuration.js").default;