velocious 1.0.494 → 1.0.495

package/build/testing/test-runner.js

@@ -187,6 +187,8 @@ export default class TestRunner {
     this._testsCount = 0
     this._activeAfterAllScopes = []
     this._failedTestDetails = []
+    /** @type {{fullDescription: string, filePath: string, line: number} | null} */
+    this._lastTestContext = null
   }
 
   /**
@@ -638,16 +640,80 @@ export default class TestRunner {
    * Runs run.
    * @returns {Promise<void>} - Resolves when complete.
    */
+  /**
+   * Records an asynchronous crash (an unhandled promise rejection detached from
+   * any await, e.g. a `void connection.afterCommit(async () => broadcast(...))`
+   * frontend-model publish) as a real, visible, attributed test failure.
+   *
+   * Without this, such a rejection has no handler, so on modern Node the process
+   * is TERMINATED — the run ends with no reported failures and CI just sees a
+   * crashed/retried shard with an empty result (the recurring "silent
+   * test-runner death": invisible and impossible to diagnose). Turning it into a
+   * failure makes the run go red with something debuggable instead of vanishing.
+   * @param {"unhandledRejection"} kind - Async-crash kind.
+   * @param {unknown} reason - Rejection reason.
+   * @returns {void}
+   */
+  recordAsyncCrash(kind, reason) {
+    const error = reason instanceof Error ? reason : new Error(`${kind}: ${String(reason)}`)
+    const near = this._lastTestContext
+    const attribution = near ? `, near test: ${near.fullDescription} (${near.filePath}:${near.line})` : ""
+
+    this._failedTests = (this._failedTests || 0) + 1
+    this._failedTestDetails.push({
+      fullDescription: `<${kind} during test run${attribution}>`,
+      filePath: near ? near.filePath : "<test runner>",
+      line: near ? near.line : 0,
+      error,
+      consoleOutput: undefined
+    })
+
+    console.error(picocolors.red(`\n[test-runner] ${kind} during the test run — this would otherwise terminate the process silently and surface only as a crashed/retried shard with zero reported failures.${attribution}`))
+    console.error(error)
+  }
+
   async run() {
-    await this.getConfiguration().ensureConnections({name: "Test runner suite"}, async () => {
-      await this.runTests({
-        afterEaches: [],
-        beforeEaches: [],
-        tests,
-        descriptions: [],
-        indentLevel: 0
+    /**
+     * Handles a process-level unhandled rejection during the run.
+     * @param {unknown} reason - Rejection reason.
+     * @returns {void}
+     */
+    const onUnhandledRejection = (reason) => {
+      // If a test attached its OWN unhandledRejection listener, it is
+      // intentionally observing/triggering the rejection (e.g. beacon
+      // error-reporting-spec.js) — Node dispatches to EVERY listener, so also
+      // failing the suite here would break those tests. Defer to the test's
+      // handler; only treat a rejection as a silent-death crash when ours is the
+      // sole listener (no persistent framework listener exists to mask this).
+      if (process.listenerCount("unhandledRejection") > 1) return
+
+      this.recordAsyncCrash("unhandledRejection", reason)
+    }
+
+    process.on("unhandledRejection", onUnhandledRejection)
+
+    try {
+      await this.getConfiguration().ensureConnections({name: "Test runner suite"}, async () => {
+        await this.runTests({
+          afterEaches: [],
+          beforeEaches: [],
+          tests,
+          descriptions: [],
+          indentLevel: 0
+        })
+
+        // A rejection scheduled by the final test (a detached rejected promise,
+        // or an afterCommit callback rejecting as the suite drains) is reported
+        // by Node on a LATER turn. Drain a few turns while the handler is still
+        // attached — and connections still open — so those late rejections are
+        // recorded instead of escaping to the default crash path after cleanup.
+        for (let drainTurn = 0; drainTurn < 3; drainTurn++) {
+          await new Promise((resolve) => setImmediate(resolve))
+        }
       })
-    })
+    } finally {
+      process.off("unhandledRejection", onUnhandledRejection)
+    }
   }
 
   /**
@@ -798,6 +864,14 @@ export default class TestRunner {
                     await beforeEachData.callback({configuration: this.getConfiguration(), testArgs, testData})
                   }
 
+                  // Record which test is running so an async crash (an unhandled
+                  // rejection detached from any await) that fires during or shortly
+                  // after this test can be attributed to it in run()'s handler.
+                  this._lastTestContext = {
+                    fullDescription: this.buildFullDescription(descriptions, testDescription),
+                    filePath: testData.filePath ?? "<unknown>",
+                    line: testData.line ?? 0
+                  }
                   await testData.function(testArgs)
                   this._successfulTests++
                 } finally {

package/package.json

@@ -3,7 +3,7 @@
     "velocious": "build/bin/velocious.js"
   },
   "name": "velocious",
-  "version": "1.0.494",
+  "version": "1.0.495",
   "main": "build/index.js",
   "types": "build/index.d.ts",
   "files": [

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

@@ -40,11 +40,13 @@ const RESOURCE_STATIC_CONFIG_KEYS = new Set([
   "modelName",
   "ModelClass",
   "primaryKey",
+  "quickSearchColumns",
   "relationships",
   "server",
   "SharedResource",
   "sync",
-  "translatedAttributes"
+  "translatedAttributes",
+  "writableAttributes"
 ])
 
 /**

package/src/testing/test-runner.js

@@ -187,6 +187,8 @@ export default class TestRunner {
     this._testsCount = 0
     this._activeAfterAllScopes = []
     this._failedTestDetails = []
+    /** @type {{fullDescription: string, filePath: string, line: number} | null} */
+    this._lastTestContext = null
   }
 
   /**
@@ -638,16 +640,80 @@ export default class TestRunner {
    * Runs run.
    * @returns {Promise<void>} - Resolves when complete.
    */
+  /**
+   * Records an asynchronous crash (an unhandled promise rejection detached from
+   * any await, e.g. a `void connection.afterCommit(async () => broadcast(...))`
+   * frontend-model publish) as a real, visible, attributed test failure.
+   *
+   * Without this, such a rejection has no handler, so on modern Node the process
+   * is TERMINATED — the run ends with no reported failures and CI just sees a
+   * crashed/retried shard with an empty result (the recurring "silent
+   * test-runner death": invisible and impossible to diagnose). Turning it into a
+   * failure makes the run go red with something debuggable instead of vanishing.
+   * @param {"unhandledRejection"} kind - Async-crash kind.
+   * @param {unknown} reason - Rejection reason.
+   * @returns {void}
+   */
+  recordAsyncCrash(kind, reason) {
+    const error = reason instanceof Error ? reason : new Error(`${kind}: ${String(reason)}`)
+    const near = this._lastTestContext
+    const attribution = near ? `, near test: ${near.fullDescription} (${near.filePath}:${near.line})` : ""
+
+    this._failedTests = (this._failedTests || 0) + 1
+    this._failedTestDetails.push({
+      fullDescription: `<${kind} during test run${attribution}>`,
+      filePath: near ? near.filePath : "<test runner>",
+      line: near ? near.line : 0,
+      error,
+      consoleOutput: undefined
+    })
+
+    console.error(picocolors.red(`\n[test-runner] ${kind} during the test run — this would otherwise terminate the process silently and surface only as a crashed/retried shard with zero reported failures.${attribution}`))
+    console.error(error)
+  }
+
   async run() {
-    await this.getConfiguration().ensureConnections({name: "Test runner suite"}, async () => {
-      await this.runTests({
-        afterEaches: [],
-        beforeEaches: [],
-        tests,
-        descriptions: [],
-        indentLevel: 0
+    /**
+     * Handles a process-level unhandled rejection during the run.
+     * @param {unknown} reason - Rejection reason.
+     * @returns {void}
+     */
+    const onUnhandledRejection = (reason) => {
+      // If a test attached its OWN unhandledRejection listener, it is
+      // intentionally observing/triggering the rejection (e.g. beacon
+      // error-reporting-spec.js) — Node dispatches to EVERY listener, so also
+      // failing the suite here would break those tests. Defer to the test's
+      // handler; only treat a rejection as a silent-death crash when ours is the
+      // sole listener (no persistent framework listener exists to mask this).
+      if (process.listenerCount("unhandledRejection") > 1) return
+
+      this.recordAsyncCrash("unhandledRejection", reason)
+    }
+
+    process.on("unhandledRejection", onUnhandledRejection)
+
+    try {
+      await this.getConfiguration().ensureConnections({name: "Test runner suite"}, async () => {
+        await this.runTests({
+          afterEaches: [],
+          beforeEaches: [],
+          tests,
+          descriptions: [],
+          indentLevel: 0
+        })
+
+        // A rejection scheduled by the final test (a detached rejected promise,
+        // or an afterCommit callback rejecting as the suite drains) is reported
+        // by Node on a LATER turn. Drain a few turns while the handler is still
+        // attached — and connections still open — so those late rejections are
+        // recorded instead of escaping to the default crash path after cleanup.
+        for (let drainTurn = 0; drainTurn < 3; drainTurn++) {
+          await new Promise((resolve) => setImmediate(resolve))
+        }
       })
-    })
+    } finally {
+      process.off("unhandledRejection", onUnhandledRejection)
+    }
   }
 
   /**
@@ -798,6 +864,14 @@ export default class TestRunner {
                     await beforeEachData.callback({configuration: this.getConfiguration(), testArgs, testData})
                   }
 
+                  // Record which test is running so an async crash (an unhandled
+                  // rejection detached from any await) that fires during or shortly
+                  // after this test can be attributed to it in run()'s handler.
+                  this._lastTestContext = {
+                    fullDescription: this.buildFullDescription(descriptions, testDescription),
+                    filePath: testData.filePath ?? "<unknown>",
+                    line: testData.line ?? 0
+                  }
                   await testData.function(testArgs)
                   this._successfulTests++
                 } finally {