velocious 1.0.545 → 1.0.547

package/build/testing/test-runner.js

@@ -237,6 +237,8 @@ export default class TestRunner {
     this._failedTestDetails = []
     /** @type {{fullDescription: string, filePath: string, line: number} | null} */
     this._lastTestContext = null
+    /** @type {Array<{fullDescription: string, filePath: string, line: number, durationMs: number}>} */
+    this._testDurations = []
   }
 
   /**
@@ -696,6 +698,17 @@ export default class TestRunner {
     return this._successfulTests + this._failedTests
   }
 
+  /**
+   * Returns the tests recorded during the run, slowest first.
+   * @param {number} [limit] - Maximum number of tests to return (0 returns all).
+   * @returns {Array<{fullDescription: string, filePath: string, line: number, durationMs: number}>} - Slowest tests, slowest first.
+   */
+  getSlowestTests(limit = 10) {
+    const sorted = [...this._testDurations].sort((testA, testB) => testB.durationMs - testA.durationMs)
+
+    return limit > 0 ? sorted.slice(0, limit) : sorted
+  }
+
   /**
    * Runs prepare.
    * @returns {Promise<void>} - Resolves when complete.
@@ -706,6 +719,7 @@ export default class TestRunner {
     this._successfulTests = 0
     this._testsCount = 0
     this._failedTestDetails = []
+    this._testDurations = []
     await this.importTestFiles()
     await this.analyzeTests(tests)
     this._onlyFocussed = this.anyTestsFocussed
@@ -940,6 +954,8 @@ export default class TestRunner {
 
         console.log(`${leftPadding}it ${testDescription}`)
 
+        const testStartMs = Date.now()
+
         while (true) {
           let shouldRetry = false
           /**
@@ -1180,6 +1196,13 @@ export default class TestRunner {
 
           break
         }
+
+        this._testDurations.push({
+          fullDescription: this.buildFullDescription(descriptions, testDescription),
+          filePath: testData.filePath ?? "<unknown>",
+          line: testData.line ?? 0,
+          durationMs: Date.now() - testStartMs
+        })
       }
 
       for (const subDescription in tests.subs) {

package/package.json

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

package/src/background-jobs/store.js

@@ -55,6 +55,20 @@ const SORTABLE_COLUMNS = {
   scheduledAtMs: "scheduled_at_ms"
 }
 
+/**
+ * Serializes concurrent `_applySchema` runs within THIS process, keyed by database
+ * identifier. Two stores that share one connection (SingleMultiUse / SQLite)
+ * otherwise interleave the multi-step table rebuild and corrupt it (the jobs table
+ * is left as its `*_velocious_rebuild` temp). A DB advisory lock can't fix that: on
+ * a session-scoped / re-entrant driver (MySQL `GET_LOCK`) a second acquire on the
+ * same session succeeds immediately so both callers proceed, and taking it on a
+ * separate connection blocks cross-session forever. An in-process promise-chain
+ * mutex serializes same-process callers with neither hazard. Cross-process schema
+ * races stay covered by the per-step advisory locks + rechecks inside the steps.
+ * @type {Map<string, Promise<void>>}
+ */
+const schemaApplyChains = new Map()
+
 export default class BackgroundJobsStore {
   /**
    * Runs constructor.
@@ -804,6 +818,31 @@ export default class BackgroundJobsStore {
    * @returns {Promise<void>} - Resolves when the schema is present.
    */
   async _applySchema(db) {
+    // Serialize concurrent schema applies within this process, keyed by database
+    // identifier (see `schemaApplyChains`). The per-step locks inside the steps use
+    // DIFFERENT lock names, so two concurrent callers could otherwise each hold a
+    // different step lock while both rebuild the jobs table — and on SQLite/MSSQL an
+    // add-column is a create-copy-drop-rename rebuild, so overlapping rebuilds
+    // corrupt it. This mutex makes the whole apply mutually exclusive per process;
+    // the second caller then re-checks and finds every step already done.
+    const identifier = this.getDatabaseIdentifier() ?? "default"
+    const previous = schemaApplyChains.get(identifier) ?? Promise.resolve()
+    const run = previous.then(() => this._applySchemaSteps(db), () => this._applySchemaSteps(db))
+
+    // Keep the chain alive regardless of this run's outcome so one failed apply does
+    // not wedge later callers; this run still propagates its own result/error.
+    schemaApplyChains.set(identifier, run.then(() => {}, () => {}))
+
+    return await run
+  }
+
+  /**
+   * Creates or upgrades the background-jobs tables, columns and concurrency rows on
+   * the given connection. Serialized per process by {@link BackgroundJobsStore#_applySchema}.
+   * @param {import("../database/drivers/base.js").default} db - Database connection.
+   * @returns {Promise<void>} - Resolves when the schema is present.
+   */
+  async _applySchemaSteps(db) {
     await this._ensureMigrationsTable(db)
 
     const alreadyApplied = await this._hasMigration(db)

package/src/database/record/index.js

@@ -770,7 +770,7 @@ class VelociousDatabaseRecord {
       }
 
       prototype[`${relationshipName}OrLoad`] = async function() {
-        return await this.relationshipOrLoad(relationshipName, {preloadTranslations: true})
+        return await this.relationshipOrLoad(relationshipName)
       }
 
       prototype[`set${inflection.camelize(relationshipName)}`] = function(/** @type {VelociousDatabaseRecord | null | undefined} */ model) {

package/src/database/tenants/data-copier.js

@@ -1,5 +1,7 @@
 // @ts-check
 
+import {POOL_CONFIGURATION_KEY} from "../pool/base.js"
+
 const DEFAULT_INSERT_CHUNK_SIZE = 100
 const DEFAULT_QUERY_CHUNK_SIZE = 500
 const DEFAULT_STREAM_BATCH_SIZE = 1000
@@ -95,6 +97,56 @@ export default class DataCopier {
     return sourceRowsByTableName
   }
 
+  /**
+   * Moves every plan table's rows for `keyValue` from the source into the target. The target
+   * write commits before the source delete begins, so a target failure leaves the source
+   * untouched and a source-delete failure can be retried safely. When the source no longer has
+   * matching rows, the method returns the empty traversal without changing the target.
+   *
+   * `transformRow` can change target-only values such as a tenant ownership column. It receives
+   * a shallow clone and must preserve the configured id column so retries address the same rows.
+   * @param {string} keyValue - Tenant key selecting the rows to move.
+   * @param {{transformRow?: (args: {row: Record<string, unknown>, tableName: string}) => Record<string, unknown>}} [options] - Optional target-row transformation.
+   * @returns {Promise<Map<string, Record<string, unknown>[]>>} - Rows written to the target, grouped by table name.
+   */
+  async move(keyValue, {transformRow} = {}) {
+    const sourceDbWithPoolKey = /** @type {import("../drivers/base.js").default & {[POOL_CONFIGURATION_KEY]?: string}} */ (this.sourceDb)
+    const targetDbWithPoolKey = /** @type {import("../drivers/base.js").default & {[POOL_CONFIGURATION_KEY]?: string}} */ (this.targetDb)
+    const sourceReuseKey = sourceDbWithPoolKey[POOL_CONFIGURATION_KEY]
+    const targetReuseKey = targetDbWithPoolKey[POOL_CONFIGURATION_KEY]
+    const sameResolvedDatabase = this.sourceDb.configuration === this.targetDb.configuration
+      && sourceReuseKey !== undefined
+      && sourceReuseKey === targetReuseKey
+
+    if (this.sourceDb === this.targetDb || sameResolvedDatabase) {
+      throw new Error("DataCopier move requires different physical databases.")
+    }
+
+    const sourceRowsByTableName = await this.loadRows(this.sourceDb, keyValue)
+
+    if (!this.rowsByTableNameHasRows(sourceRowsByTableName)) {
+      return sourceRowsByTableName
+    }
+
+    const targetRowsByTableName = this.transformRows({rowsByTableName: sourceRowsByTableName, transformRow})
+
+    await this.targetDb.withDisabledForeignKeys(async () => {
+      await this.targetDb.transaction(async () => {
+        await this.deleteRows({db: this.targetDb, rowsByTableName: sourceRowsByTableName})
+        await this.insertRows({db: this.targetDb, rowsByTableName: targetRowsByTableName})
+        await this.assertRowsExist({db: this.targetDb, rowsByTableName: targetRowsByTableName})
+      })
+    })
+
+    await this.sourceDb.withDisabledForeignKeys(async () => {
+      await this.sourceDb.transaction(async () => {
+        await this.deleteRows({db: this.sourceDb, rowsByTableName: sourceRowsByTableName})
+      })
+    })
+
+    return targetRowsByTableName
+  }
+
   /**
    * Deletes one tenant's rows from the target database, children before parents, with
    * foreign keys disabled inside a single transaction. This is `copy` without the reinsert:
@@ -409,6 +461,15 @@ export default class DataCopier {
    * @returns {Promise<void>}
    */
   async deleteTargetRows(rowsByTableName) {
+    await this.deleteRows({db: this.targetDb, rowsByTableName})
+  }
+
+  /**
+   * Deletes the supplied rows from `db`, children before parents.
+   * @param {{db: import("../drivers/base.js").default, rowsByTableName: Map<string, Record<string, unknown>[]>}} args - Database and rows to delete.
+   * @returns {Promise<void>}
+   */
+  async deleteRows({db, rowsByTableName}) {
     for (const tableConfig of [...this.tablePlan].reverse()) {
       const rowIds = uniqueStrings((rowsByTableName.get(tableConfig.tableName) || []).map((row) => row[this.idColumn]))
 
@@ -416,13 +477,13 @@ export default class DataCopier {
         continue
       }
 
-      const quotedTable = this.targetDb.quoteTable(tableConfig.tableName)
-      const quotedIdColumn = this.targetDb.quoteColumn(this.idColumn)
+      const quotedTable = db.quoteTable(tableConfig.tableName)
+      const quotedIdColumn = db.quoteColumn(this.idColumn)
 
       for (const rowIdsChunk of chunks(rowIds, this.queryChunkSize)) {
         await this.executeQuietQuery(
-          this.targetDb,
-          `DELETE FROM ${quotedTable} WHERE ${quotedIdColumn} IN (${this.quotedValuesSql(this.targetDb, rowIdsChunk)})`
+          db,
+          `DELETE FROM ${quotedTable} WHERE ${quotedIdColumn} IN (${this.quotedValuesSql(db, rowIdsChunk)})`
         )
       }
     }
@@ -435,6 +496,15 @@ export default class DataCopier {
    * @returns {Promise<void>}
    */
   async insertTargetRows(rowsByTableName) {
+    await this.insertRows({db: this.targetDb, rowsByTableName})
+  }
+
+  /**
+   * Inserts the supplied rows into `db`, parents before children.
+   * @param {{db: import("../drivers/base.js").default, rowsByTableName: Map<string, Record<string, unknown>[]>}} args - Database and rows to insert.
+   * @returns {Promise<void>}
+   */
+  async insertRows({db, rowsByTableName}) {
     for (const tableConfig of this.tablePlan) {
       const rows = rowsByTableName.get(tableConfig.tableName) || []
 
@@ -450,7 +520,7 @@ export default class DataCopier {
       for (const rowsChunk of insertChunks) {
         await this.insertRowsQuietly({
           columns,
-          db: this.targetDb,
+          db,
           rows: rowsChunk.map((row) => columns.map((column) => row[column])),
           tableName: tableConfig.tableName
         })
@@ -458,6 +528,65 @@ export default class DataCopier {
     }
   }
 
+  /**
+   * Returns whether any table in the loaded traversal contains rows.
+   * @param {Map<string, Record<string, unknown>[]>} rowsByTableName - Rows grouped by table name.
+   * @returns {boolean} - Whether any table contains rows.
+   */
+  rowsByTableNameHasRows(rowsByTableName) {
+    for (const rows of rowsByTableName.values()) {
+      if (rows.length > 0) {
+        return true
+      }
+    }
+
+    return false
+  }
+
+  /**
+   * Clones source rows and applies the optional target-only transformation.
+   * @param {{rowsByTableName: Map<string, Record<string, unknown>[]>, transformRow?: (args: {row: Record<string, unknown>, tableName: string}) => Record<string, unknown>}} args - Source rows and optional transformation.
+   * @returns {Map<string, Record<string, unknown>[]>} - Cloned rows prepared for the target.
+   */
+  transformRows({rowsByTableName, transformRow}) {
+    const transformedRowsByTableName = new Map()
+
+    for (const tableConfig of this.tablePlan) {
+      const sourceRows = rowsByTableName.get(tableConfig.tableName) || []
+      const transformedRows = sourceRows.map((sourceRow) => {
+        const transformedRow = transformRow
+          ? transformRow({row: {...sourceRow}, tableName: tableConfig.tableName})
+          : {...sourceRow}
+
+        if (String(transformedRow[this.idColumn]) !== String(sourceRow[this.idColumn])) {
+          throw new Error(`DataCopier move transform must preserve ${this.idColumn} for table ${tableConfig.tableName}.`)
+        }
+
+        return transformedRow
+      })
+
+      transformedRowsByTableName.set(tableConfig.tableName, transformedRows)
+    }
+
+    return transformedRowsByTableName
+  }
+
+  /**
+   * Verifies that every supplied row id exists in `db`.
+   * @param {{db: import("../drivers/base.js").default, rowsByTableName: Map<string, Record<string, unknown>[]>}} args - Database and rows to verify.
+   * @returns {Promise<void>}
+   */
+  async assertRowsExist({db, rowsByTableName}) {
+    for (const tableConfig of this.tablePlan) {
+      const expectedIds = uniqueStrings((rowsByTableName.get(tableConfig.tableName) || []).map((row) => row[this.idColumn]))
+      const existingIds = await this.queryExistingIds({db, ids: expectedIds, tableName: tableConfig.tableName})
+
+      if (existingIds.size !== expectedIds.length) {
+        throw new Error(`DataCopier move target verification failed for table ${tableConfig.tableName}.`)
+      }
+    }
+  }
+
   /**
    * Quotes and comma-joins values for an SQL `IN (...)` list against the given database.
    * @param {import("../drivers/base.js").default} db - Database whose quoting rules format the values.

package/src/environment-handlers/node/cli/commands/generate/base-models.js

@@ -1,3 +1,5 @@
+// @ts-check
+
 import BaseCommand from "../../../../../cli/base-command.js"
 import deburrColumnName from "../../../../../utils/deburr-column-name.js"
 import fileExists from "../../../../../utils/file-exists.js"
@@ -339,7 +341,7 @@ export default class DbGenerateModel extends BaseCommand {
           fileContent += "  /**\n"
           fileContent += `   * @returns {Promise<import("${modelFilePath}").default | undefined>}\n`
           fileContent += "   */\n"
-          fileContent += `  ${relationship.getRelationshipName()}OrLoad() { return /** @type {Promise<import("${modelFilePath}").default | undefined>} */ (this.relationshipOrLoad("${relationship.getRelationshipName()}", {preloadTranslations: true})) }\n`
+          fileContent += `  ${relationship.getRelationshipName()}OrLoad() { return /** @type {Promise<import("${modelFilePath}").default | undefined>} */ (this.relationshipOrLoad("${relationship.getRelationshipName()}")) }\n`
 
           fileContent += "\n"
           fileContent += "  /**\n"

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

@@ -86,6 +86,25 @@ export default class VelociousCliCommandsTest extends BaseCommand {
       process.exit(1)
     }
 
+    // Report the slowest tests so suite hotspots are visible every run. Defaults to
+    // the top 10; tune with VELOCIOUS_SLOW_TEST_COUNT (0 disables). Skipped for
+    // single-test runs where it would just be noise.
+    const slowTestCount = resolveSlowTestCount(process.env.VELOCIOUS_SLOW_TEST_COUNT)
+
+    if (slowTestCount > 0 && executedTests > 1) {
+      const slowestTests = testRunner.getSlowestTests(slowTestCount)
+
+      if (slowestTests.length > 0) {
+        console.log(picocolors.cyan(`\nSlowest ${slowestTests.length} tests:`))
+
+        for (const slowTest of slowestTests) {
+          const location = slowTest.filePath && slowTest.line ? ` (${slowTest.filePath}:${slowTest.line})` : ""
+
+          console.log(picocolors.cyan(`  ${String(slowTest.durationMs).padStart(6)}ms  ${slowTest.fullDescription}${location}`))
+        }
+      }
+    }
+
     if (testRunner.isFailed()) {
       await testRunner.persistFailedTestConsoleOutputsToAssets()
       const failedTests = testRunner.getFailedTestDetails()
@@ -116,3 +135,16 @@ export default class VelociousCliCommandsTest extends BaseCommand {
     }
   }
 }
+
+/**
+ * Resolves how many slowest tests to report from the `VELOCIOUS_SLOW_TEST_COUNT`
+ * env value: defaults to 10 when unset; 0 (or an unparseable value) disables the
+ * report; otherwise the floored, non-negative integer.
+ * @param {string | undefined} rawEnvValue - Raw env value.
+ * @returns {number} - Number of slowest tests to report (0 disables).
+ */
+export function resolveSlowTestCount(rawEnvValue) {
+  if (rawEnvValue === undefined) return 10
+
+  return Math.max(0, Math.floor(Number(rawEnvValue)) || 0)
+}

package/src/testing/test-runner.js

@@ -237,6 +237,8 @@ export default class TestRunner {
     this._failedTestDetails = []
     /** @type {{fullDescription: string, filePath: string, line: number} | null} */
     this._lastTestContext = null
+    /** @type {Array<{fullDescription: string, filePath: string, line: number, durationMs: number}>} */
+    this._testDurations = []
   }
 
   /**
@@ -696,6 +698,17 @@ export default class TestRunner {
     return this._successfulTests + this._failedTests
   }
 
+  /**
+   * Returns the tests recorded during the run, slowest first.
+   * @param {number} [limit] - Maximum number of tests to return (0 returns all).
+   * @returns {Array<{fullDescription: string, filePath: string, line: number, durationMs: number}>} - Slowest tests, slowest first.
+   */
+  getSlowestTests(limit = 10) {
+    const sorted = [...this._testDurations].sort((testA, testB) => testB.durationMs - testA.durationMs)
+
+    return limit > 0 ? sorted.slice(0, limit) : sorted
+  }
+
   /**
    * Runs prepare.
    * @returns {Promise<void>} - Resolves when complete.
@@ -706,6 +719,7 @@ export default class TestRunner {
     this._successfulTests = 0
     this._testsCount = 0
     this._failedTestDetails = []
+    this._testDurations = []
     await this.importTestFiles()
     await this.analyzeTests(tests)
     this._onlyFocussed = this.anyTestsFocussed
@@ -940,6 +954,8 @@ export default class TestRunner {
 
         console.log(`${leftPadding}it ${testDescription}`)
 
+        const testStartMs = Date.now()
+
         while (true) {
           let shouldRetry = false
           /**
@@ -1180,6 +1196,13 @@ export default class TestRunner {
 
           break
         }
+
+        this._testDurations.push({
+          fullDescription: this.buildFullDescription(descriptions, testDescription),
+          filePath: testData.filePath ?? "<unknown>",
+          line: testData.line ?? 0,
+          durationMs: Date.now() - testStartMs
+        })
       }
 
       for (const subDescription in tests.subs) {