velocious 1.0.465 → 1.0.467

package/README.md

@@ -578,6 +578,7 @@ Use `await FrontendModelBase.waitForIdle()` when a test harness or app lifecycle
 Frontend-model HTTP requests always use `credentials: "include"` so shared custom commands can set session cookies without app-level transport overrides.
 
 Unexpected frontend-model endpoint failures stay client-safe in production with `errorMessage: "Request failed."`.
+Invalid client query descriptors, such as unknown `select`, `where`, `search`, `joins`, `group`, `sort`, `pluck`, or Ransack attributes, return the specific frontend-model query error message with `velocious.code: "frontend-model-query-error"` and are not emitted as framework errors.
 In `development` and `test`, Velocious also includes `debugErrorClass`, `debugErrorMessage`, and `debugBacktrace` fields so browser/system-test failures are easier to diagnose without exposing those details in production.
 Other non-production environments, such as `staging`, keep the same client-safe default unless you explicitly opt in with `exposeInternalErrorsToClients: true`:
 
@@ -1619,7 +1620,7 @@ configuration.getErrorEvents().on("all-error", ({error, errorType}) => {
 })
 ```
 
-Genuinely unexpected frontend-model command failures reach this bus too. The frontend-model controller catches them to return a client-safe `Request failed.` response, but it also emits them as `framework-error`/`all-error` (with `context.frontendModelEndpoint === true`) so they are reported instead of being silently swallowed. Expected user-flow errors are excluded: validation failures are forwarded with their real message (for example `Name can't be blank`) rather than the generic one, and `error.velocious`-annotated / `safeToExpose` / `errorType`-marked errors keep their expected-error status — none of these reach the error bus.
+Genuinely unexpected frontend-model command failures reach this bus too. The frontend-model controller catches them to return a client-safe `Request failed.` response, but it also emits them as `framework-error`/`all-error` (with `context.frontendModelEndpoint === true`) so they are reported instead of being silently swallowed. Expected user-flow errors are excluded: validation failures are forwarded with their real message (for example `Name can't be blank`), invalid client query descriptors are returned as frontend-model query errors, and `error.velocious`-annotated / `safeToExpose` / `errorType`-marked errors keep their expected-error status — none of these reach the error bus.
 
 ## Use the Websocket client API (HTTP-like)
 

package/build/configuration.js

@@ -2230,8 +2230,8 @@ export default class VelociousConfiguration {
 
       if (!matches) continue
 
-      this.withoutCurrentConnectionContexts(() => {
-        void Promise
+      void this.withoutCurrentConnectionContexts(() => {
+        return Promise
           .resolve()
           .then(() => this._deliverWebsocketChannelBroadcast(subscription, body, {eventId: meta?.eventId}))
           .catch((error) => {

package/build/database/pool/async-tracked-multi-connection.js

@@ -6,6 +6,7 @@ import BasePool, {POOL_CONFIGURATION_KEY} from "./base.js"
 export const CLOSED_CONNECTION = Symbol("velociousClosedConnection")
 const IDLE_CONNECTION_CHECKED_IN_AT = Symbol("velociousIdleConnectionCheckedInAt")
 const CONNECTION_CHECKED_OUT_AT = Symbol("velociousConnectionCheckedOutAt")
+const SUPPRESSED_CONNECTION_CONTEXT = Symbol("velociousSuppressedConnectionContext")
 const DEFAULT_MAX_CONNECTIONS = 10
 const DEFAULT_IDLE_TIMEOUT_MILLIS = 5000
 const DEFAULT_CHECKOUT_TIMEOUT_MILLIS = 10000
@@ -103,7 +104,7 @@ export default class VelociousDatabasePoolAsyncTrackedMultiConnection extends Ba
      * Runs a callback without the inherited current connection context.
      * @type {(callback: () => ?) => ?}
      */
-    const withoutCurrentConnectionContext = (callback) => this.asyncLocalStorage.run(undefined, callback)
+    const withoutCurrentConnectionContext = (callback) => this.asyncLocalStorage.run(SUPPRESSED_CONNECTION_CONTEXT, callback)
     this._withoutCurrentConnectionContext = withoutCurrentConnectionContext
   }
 
@@ -720,6 +721,7 @@ export default class VelociousDatabasePoolAsyncTrackedMultiConnection extends Ba
     const id = this.asyncLocalStorage.getStore()
 
     if (id === undefined) return this.currentFallbackConnectionOrFail()
+    if (id === SUPPRESSED_CONNECTION_CONTEXT) return this.currentFallbackConnectionOrFail()
 
     this.ensureConnectionIsInUse(id)
 
@@ -815,6 +817,7 @@ export default class VelociousDatabasePoolAsyncTrackedMultiConnection extends Ba
   getCurrentContextConnection() {
     const id = this.asyncLocalStorage.getStore()
 
+    if (id === SUPPRESSED_CONNECTION_CONTEXT) return undefined
     if (id === undefined) return this._testSharedConnection
 
     return this.getCurrentConnection()
@@ -825,7 +828,9 @@ export default class VelociousDatabasePoolAsyncTrackedMultiConnection extends Ba
    * @returns {boolean} - Whether nested code can reuse the current connection context.
    */
   hasCurrentConnectionContext() {
-    return this.asyncLocalStorage.getStore() !== undefined
+    const id = this.asyncLocalStorage.getStore()
+
+    return id !== undefined && id !== SUPPRESSED_CONNECTION_CONTEXT
   }
 
   /**

package/build/database/pool/single-multi-use.js

@@ -3,6 +3,8 @@
 import BasePool from "./base.js"
 
 export default class VelociousDatabasePoolSingleMultiUser extends BasePool {
+  suppressedConnectionContextCount = 0
+
   /**
    * Runs checkin.
    * @param {import("../drivers/base.js").default} connection - Connection.
@@ -58,6 +60,32 @@ export default class VelociousDatabasePoolSingleMultiUser extends BasePool {
     }
   }
 
+  /**
+   * Runs without current connection context.
+   * @template T
+   * @param {() => T} callback - Callback to run without the shared current connection.
+   * @returns {T} - Callback result.
+   */
+  withoutCurrentConnectionContext(callback) {
+    this.suppressedConnectionContextCount += 1
+
+    try {
+      const result = callback()
+
+      if (result instanceof Promise) {
+        return /** @type {T} */ (result.finally(() => {
+          this.suppressedConnectionContextCount -= 1
+        }))
+      }
+
+      this.suppressedConnectionContextCount -= 1
+      return result
+    } catch (error) {
+      this.suppressedConnectionContextCount -= 1
+      throw error
+    }
+  }
+
   /**
    * Clears schema metadata cached by the reusable connection if it exists.
    * @returns {void} - No return value.
@@ -97,9 +125,19 @@ export default class VelociousDatabasePoolSingleMultiUser extends BasePool {
    * @returns {import("../drivers/base.js").default | undefined} - The current context connection.
    */
   getCurrentContextConnection() {
+    if (this.suppressedConnectionContextCount > 0) return undefined
+
     return this.connection
   }
 
+  /**
+   * Returns whether the shared connection is available to the current execution context.
+   * @returns {boolean} - Whether nested code can reuse the shared connection.
+   */
+  hasCurrentConnectionContext() {
+    return this.suppressedConnectionContextCount === 0
+  }
+
   /**
    * Runs get debug snapshot.
    * @returns {import("./base.js").DatabasePoolDebugSnapshot} - Diagnostic snapshot for this pool.

package/build/environment-handlers/node/cli/commands/lint/relationships.js

@@ -3,6 +3,12 @@
 import BaseCommand from "../../../../../cli/base-command.js"
 import fs from "node:fs/promises"
 import path from "node:path"
+import requireContext from "require-context"
+
+/**
+ * @typedef {(id: string) => {default: typeof import("../../../../../database/record/index.js").default}} ModelFileRequireContextIdFunctionType
+ * @typedef {ModelFileRequireContextIdFunctionType & {keys: () => string[]}} ModelFileRequireContextType
+ */
 
 /**
  * Lints model relationships: every non-polymorphic belongs-to relationship should have an inverse
@@ -27,7 +33,9 @@ export default class VelociousCliCommandsLintRelationships extends BaseCommand {
     // current configuration, so make this command's configuration the current one.
     this.getConfiguration().setCurrent()
 
-    await this.getConfiguration().initializeModels()
+    if (!await this._registerStaticModelFiles()) {
+      await this.getConfiguration().initializeModels()
+    }
 
     const ignoredRelationships = await this._loadIgnoredRelationships()
     const offences = []
@@ -66,7 +74,11 @@ export default class VelociousCliCommandsLintRelationships extends BaseCommand {
           if (candidate.through) return false
 
           try {
-            return candidate.getTargetModelClass() === modelClass
+            const candidateTargetModelClass = candidate.getTargetModelClass()
+
+            if (!candidateTargetModelClass) return false
+
+            return this._modelClassesMatch(candidateTargetModelClass, modelClass)
           } catch {
             // A has-many/has-one with an unresolvable target can't be the inverse of this belongs-to.
             // It is reported separately when its own model's belongs-to relationships are linted.
@@ -97,6 +109,87 @@ export default class VelociousCliCommandsLintRelationships extends BaseCommand {
     return {offences}
   }
 
+  /**
+   * Registers model classes from the conventional src/models directory without
+   * running the application's full database/server initialization.
+   * @returns {Promise<boolean>} Whether static model files were registered.
+   */
+  async _registerStaticModelFiles() {
+    if (this.args.testing) return false
+
+    const modelsDirectory = path.join(this.directory(), "src/models")
+
+    try {
+      const stats = await fs.stat(modelsDirectory)
+
+      if (!stats.isDirectory()) return false
+    } catch (error) {
+      if (/** @type {NodeJS.ErrnoException} */ (error).code == "ENOENT") return false
+
+      throw error
+    }
+
+    if ((await this._javascriptFilesInDirectory(modelsDirectory)).length === 0) return false
+
+    /** @type {ModelFileRequireContextType} */
+    const requireContextModels = requireContext(modelsDirectory, true, /^(.+)\.js$/)
+
+    const modelFileNames = requireContextModels.keys()
+    for (const fileName of modelFileNames) {
+      const modelClassImport = requireContextModels(fileName)
+      const modelClass = modelClassImport.default
+
+      if (!modelClass) {
+        throw new Error(`Model wasn't exported from: ${fileName}`)
+      }
+
+      modelClass.registerRecordClass({configuration: this.getConfiguration()})
+    }
+
+    return true
+  }
+
+  /**
+   * Finds JavaScript files below a directory.
+   * @param {string} directory - Directory to scan.
+   * @returns {Promise<string[]>} JavaScript file paths.
+   */
+  async _javascriptFilesInDirectory(directory) {
+    const filePaths = []
+    const entries = await fs.readdir(directory, {withFileTypes: true})
+
+    for (const entry of entries) {
+      const entryPath = path.join(directory, entry.name)
+
+      if (entry.isDirectory()) {
+        filePaths.push(...await this._javascriptFilesInDirectory(entryPath))
+        continue
+      }
+
+      if (entry.isFile() && entry.name.endsWith(".js")) {
+        filePaths.push(entryPath)
+      }
+    }
+
+    return filePaths
+  }
+
+  /**
+   * Checks whether two model class objects describe the same registered model.
+   * @param {typeof import("../../../../../database/record/index.js").default} leftModelClass - Candidate target model class.
+   * @param {typeof import("../../../../../database/record/index.js").default} rightModelClass - Belongs-to source model class.
+   * @returns {boolean} Whether both model classes represent the same model identity.
+   */
+  _modelClassesMatch(leftModelClass, rightModelClass) {
+    if (leftModelClass === rightModelClass) return true
+    // `translates()` creates an internal translation class; apps may also define
+    // a concrete class for the same model/table so generated code has a stable
+    // file and type name.
+    if (leftModelClass.getModelName() != rightModelClass.getModelName()) return false
+
+    return leftModelClass.tableName() == rightModelClass.tableName()
+  }
+
   /**
    * Loads the ignored relationship keys from the lint config file. The file is optional; when the
    * default path doesn't exist, no relationships are ignored. An explicitly passed `--config` path