velocious 1.0.652 → 1.0.654

package/src/database/query/where-in.js

@@ -0,0 +1,48 @@
+// @ts-check
+
+/** @typedef {string | number | boolean | null} InValue */
+
+export default class WhereIn {
+  /**
+   * Validates an explicit membership descriptor at a column boundary.
+   * @param {unknown} condition - Untrusted column condition, narrowed before use.
+   * @returns {InValue[]} - Validated members in a new array.
+   */
+  static values(condition) {
+    if (condition === null || typeof condition !== "object" ||
+      !Object.hasOwn(condition, "in") || !("in" in condition) ||
+      Reflect.ownKeys(condition).length !== 1 || !Array.isArray(condition.in)) {
+      throw new Error("Invalid IN condition: expected an object with only an own 'in' array")
+    }
+
+    /** @type {InValue[]} */
+    const values = []
+
+    for (const value of condition.in) {
+      if (value !== null && typeof value !== "string" && typeof value !== "boolean" &&
+        !(typeof value === "number" && Number.isFinite(value))) {
+        throw new Error("Invalid IN condition: members must be strings, finite numbers, booleans or null")
+      }
+
+      values.push(value)
+    }
+
+    return values
+  }
+
+  /**
+   * Renders membership without letting its null branch escape sibling filters.
+   * @param {{columnSql: string, inColumnSql?: string, values: InValue[], options: import("../query-parser/options.js").default}} args - Quoted column operands, normalized members and driver quoting.
+   * @returns {string} - Complete membership predicate.
+   */
+  static toSql({columnSql, inColumnSql = columnSql, values, options}) {
+    const nonNullValues = values.filter((value) => value !== null)
+    const includesNull = values.includes(null)
+
+    if (nonNullValues.length === 0) return includesNull ? `${columnSql} IS NULL` : "1=0"
+
+    const membershipSql = `${inColumnSql} IN (${nonNullValues.map((value) => options.quote(value)).join(", ")})`
+
+    return includesNull ? `(${membershipSql} OR ${columnSql} IS NULL)` : membershipSql
+  }
+}

package/src/database/query/where-model-class-hash.js

@@ -3,6 +3,7 @@
 import * as inflection from "inflection"
 import {isPlainObject} from "is-plain-object"
 import WhereBase from "./where-base.js"
+import WhereIn from "./where-in.js"
 
 /**
  * No match.
@@ -378,6 +379,34 @@ export default class VelociousDatabaseQueryWhereModelClassHash extends WhereBase
     return normalized
   }
 
+  /**
+   * Normalizes explicit membership through the model's column metadata.
+   * @param {{modelClass: typeof import("../record/index.js").default, columnName: string, tableName?: string, condition: unknown}} args - Resolved column and untrusted membership descriptor.
+   * @returns {string} - Complete column membership predicate.
+   */
+  _whereSQLFromInCondition({modelClass, columnName, tableName, condition}) {
+    const options = this.getOptions()
+    const values = WhereIn.values(condition)
+    const normalizedValues = this._normalizeSqliteBooleanValue({columnName, modelClass, value: values})
+    /** @type {import("./where-in.js").InValue[] | typeof NO_MATCH} */
+    const typedValues = this._normalizeValueForColumnType({columnName, modelClass, value: normalizedValues})
+
+    if (typedValues === NO_MATCH) return "1=0"
+
+    const columnSql = tableName
+      ? `${options.quoteTableName(tableName)}.${options.quoteColumnName(columnName)}`
+      : options.quoteColumnName(columnName)
+    const columnType = modelClass.getColumnTypeByName(columnName)
+    const castText = this.getQuery().driver.getType() === "mssql" && columnType?.toLowerCase() === "text"
+
+    return WhereIn.toSql({
+      columnSql,
+      inColumnSql: castText ? `CAST(${columnSql} AS NVARCHAR(MAX))` : columnSql,
+      options,
+      values: typedValues
+    })
+  }
+
   /**
    * Runs where sqlfrom hash.
    * @param {WhereHash} hash - Hash.
@@ -400,7 +429,11 @@ export default class VelociousDatabaseQueryWhereModelClassHash extends WhereBase
         : null
       const resolvedColumnName = this._resolveColumnName(modelClass, whereKey)
 
-      if (relationship && tuples) {
+      if (resolvedColumnName && !relationship && isPlainObject(whereValue)) {
+        if (index > 0) sql += " AND "
+
+        sql += this._whereSQLFromInCondition({columnName: resolvedColumnName, condition: whereValue, modelClass, tableName})
+      } else if (relationship && tuples) {
         if (index > 0) sql += " AND "
 
         const rawTargetModelClass = relationship.getTargetModelClass()

package/src/environment-handlers/node/cli/commands/test.js

@@ -203,7 +203,7 @@ export default class VelociousCliCommandsTest extends BaseCommand {
       const hasExampleFilters = examplePatterns.length > 0
       const hasTagFilters = includeTags.length > 0 || effectiveExcludeTagCount > 0
 
-      if ((hasTagFilters || hasLineFilters || hasExampleFilters) && executedTests === 0) {
+      if ((hasTagFilters || hasLineFilters || hasExampleFilters) && testRunner.hasNoMatches()) {
         console.error(picocolors.red("\nNo tests matched the provided filters"))
         await finalizeProfile("no-tests")
         process.exit(1)
@@ -247,6 +247,7 @@ export default class VelociousCliCommandsTest extends BaseCommand {
           }
         }
 
+        if (testRunner.getNotRunTests() > 0) console.error(`${testRunner.getNotRunTests()} tests not run because a shared resource failed`)
         console.error(picocolors.red(`\nTest run failed with ${testRunner.getFailedTests()} failed tests and ${testRunner.getSuccessfulTests()} successfull`))
         await finalizeProfile("failed")
         process.exit(1)

package/src/testing/test-runner.js

@@ -142,6 +142,8 @@ import VelociousTestArguments from "./velocious-test-arguments.js"
  * @property {import("../database/pool/base.js").TestSharedConnectionRegistration | undefined} sharedRegistration - Physical-key shared registration once published.
  */
 
+const testingPackageDirectory = path.dirname(fileURLToPath(import.meta.resolve("@velocious/testing/package.json")))
+
 /**
  * Runs to file slug.
  * @param {string} value - Value to sanitize.
@@ -197,6 +199,8 @@ export default class TestRunner {
     this._successfulTests = 0
     this._testsCount = 0
     this._failedTestDetails = []
+    /** @type {import("@velocious/testing/runner").NonRunTestResult[]} */
+    this._notRunTestDetails = []
     /** @type {{fullDescription: string, filePath: string, line: number} | null} */
     this._lastTestContext = null
     /** @type {Array<{fullDescription: string, filePath: string, line: number, durationMs: number}>} */
@@ -1007,6 +1011,25 @@ export default class TestRunner {
     return this._failedTests
   }
 
+  /**
+   * Counts selected tests blocked by a terminal resource.
+   * @returns {number} - Selected tests not executed because a shared resource failed.
+   */
+  getNotRunTests() { return this._notRunTestDetails.length }
+
+  /**
+   * Returns runtime non-run attribution.
+   * @returns {import("@velocious/testing/runner").NonRunTestResult[]} - Runtime non-run details with the originating failure.
+   */
+  getNotRunTestDetails() { return this._notRunTestDetails }
+
+  /**
+   * Records a selected test that did not execute.
+   * @param {import("@velocious/testing/runner").NonRunTestResult} result - Terminal-resource non-run record.
+   * @returns {void}
+   */
+  recordNotRunTest(result) { this._notRunTestDetails.push(result) }
+
   /**
    * Runs get failed test details.
    * @returns {FailedTestDetail[]} - Failed test details.
@@ -1087,6 +1110,14 @@ export default class TestRunner {
     return this._packageResult?.tests.length ?? this._testDurations.length
   }
 
+  /**
+   * Distinguishes an empty selection from a failure before selected cases execute.
+   * @returns {boolean} - Whether selection matched no declarations.
+   */
+  hasNoMatches() {
+    return this._packageResult?.noMatches === true
+  }
+
   /**
    * Returns the tests recorded during the run, slowest first.
    * @param {number} [limit] - Maximum number of tests to return (0 returns all).
@@ -1105,6 +1136,7 @@ export default class TestRunner {
   async prepare() {
     this.anyTestsFocussed = false
     this._failedTests = 0
+    this._notRunTestDetails = []
     this._successfulTests = 0
     this._testsCount = 0
     this._abortRemainingTests = false
@@ -1177,7 +1209,7 @@ export default class TestRunner {
 
       if (portablePath.endsWith("/src/testing/test-runner.js")) continue
       if (portablePath.endsWith("/src/testing/test.js")) continue
-      if (portablePath.includes("/node_modules/@velocious/testing/")) continue
+      if (resolvedFilePath.startsWith(`${testingPackageDirectory}${path.sep}`)) continue
 
       return {filePath: resolvedFilePath, line: Number(match[2])}
     }

package/src/testing/velocious-runner-reporter.js

@@ -1,7 +1,6 @@
 // @ts-check
 
 import { addTrackedStackToError } from "../utils/with-tracked-stack.js"
-import BacktraceCleaner from "../utils/backtrace-cleaner-node.js"
 import picocolors from "picocolors"
 import restArgsError from "../utils/rest-args-error.js"
 import { testEvents } from "./test.js"
@@ -21,6 +20,8 @@ function errorFromPackageRecord(errorRecord) {
 
   error.name = errorRecord.name
   if (errorRecord.stack) error.stack = errorRecord.stack
+  if (errorRecord.cause) error.cause = errorFromPackageRecord(errorRecord.cause)
+  if (errorRecord.terminalResource) Object.assign(error, {terminalResource: errorRecord.terminalResource})
 
   return error
 }
@@ -68,7 +69,27 @@ export default class VelociousRunnerReporter {
       return
     }
 
-    if (event.type === "run:finish") this.testRunner.recordPackageResult(event.result)
+    if (event.type === "test:not-run") {
+      const test = this.testRunner.findTestDeclaration(event.test.fullName)
+      if (!test) throw new Error(`Package not-run result did not match a declaration: ${event.test.fullName}`)
+      this.testRunner.recordNotRunTest(event.test)
+      this.testRunner.completeTestDeclaration(test)
+      console.error(`Not run: ${event.test.fullName} (terminal resource failure in ${event.test.reason.fullName})`)
+      await this.emitEvent("testNotRun", {
+        configuration: this.testRunner.getConfiguration(),
+        test: event.test,
+        testRunner: this.testRunner
+      })
+      return
+    }
+
+    if (event.type === "run:finish") {
+      this.testRunner.recordPackageResult(event.result)
+      for (const failure of event.result.errors) {
+        console.error(`Suite ${failure.phase} failed: ${failure.suite}`)
+        this.printErrorCauses(errorFromPackageRecord(failure.error))
+      }
+    }
   }
 
   /**
@@ -95,7 +116,7 @@ export default class VelociousRunnerReporter {
     const failed = outcome?.failed ?? Boolean(attempt.error)
     const error = outcome?.error
     const retriesUsed = Math.min(attempt.attemptNumber, retryCount)
-    const willRetry = failed && !outcome?.abortRemainingTests && attempt.attemptNumber <= retryCount
+    const willRetry = failed && !event.terminalFailure && !outcome?.abortRemainingTests && attempt.attemptNumber <= retryCount
     const {descriptions, testDescription} = this.testRunner.testMetadata(test)
     const compatibility = this.testRunner.testData(test)
 
@@ -245,15 +266,8 @@ export default class VelociousRunnerReporter {
 
     if (error instanceof Error) {
       console.error(picocolors.red(`${leftPadding}  Test failed: ${error.message}`))
-      addTrackedStackToError(error)
-
-      const backtraceCleaner = new BacktraceCleaner(error)
-      const cleanedStack = backtraceCleaner.getCleanedStack()
-      const stackLines = cleanedStack?.split("\n")
+      this.printErrorCauses(error)
 
-      if (stackLines) {
-        for (const stackLine of stackLines) console.error(picocolors.red(`${leftPadding}  ${stackLine}`))
-      }
     } else {
       console.error(picocolors.red(`${leftPadding}  Test failed with a ${typeof error}: ${String(error)}`))
     }
@@ -274,6 +288,33 @@ export default class VelociousRunnerReporter {
     testRunner.printRerunCommand({descriptions, testDescription, testData, leftPadding})
   }
 
+  /**
+   * Prints complete primary and secondary stacks once, including cyclic cause graphs.
+   * @param {unknown} error - Thrown value at the reporting boundary.
+   * @param {Set<Error>} [reported] - Error identities already printed.
+   * @returns {void}
+   */
+  printErrorCauses(error, reported = new Set()) {
+    if (!(error instanceof Error)) {
+      console.error(String(error))
+      return
+    }
+    if (reported.has(error)) return
+    reported.add(error)
+    addTrackedStackToError(error)
+    console.error(error.stack || `${error.name}: ${error.message}`)
+    if (error.cause !== undefined) {
+      console.error("Caused by:")
+      this.printErrorCauses(error.cause, reported)
+    }
+    if (error instanceof AggregateError) {
+      for (const secondary of error.errors) {
+        console.error("Related failure:")
+        this.printErrorCauses(secondary, reported)
+      }
+    }
+  }
+
   /**
    * Emits one legacy event and awaits listeners in registration order.
    * @param {string} eventName - Event name.