velocious 1.0.533 → 1.0.535

package/src/database/migration/index.js

@@ -468,6 +468,26 @@ export default class VelociousDatabaseMigration {
     return Boolean(false)
   }
 
+  /**
+   * Checks whether an index with the given name exists on a table.
+   * @param {string} tableName - Table name.
+   * @param {string} indexName - Index name to look for.
+   * @returns {Promise<boolean>} - Whether the index exists on the table.
+   */
+  async indexExists(tableName, indexName) {
+    const table = await this.getDriver().getTableByName(tableName, {throwError: false})
+
+    if (table) {
+      for (const index of await table.getIndexes()) {
+        if (index.getName() == indexName) {
+          return true
+        }
+      }
+    }
+
+    return false
+  }
+
   /**
    * Sets up the database schema for a gap-less positional list. Adds the
    * position column (INT NOT NULL) if absent and creates a UNIQUE index on

package/src/database/migrator.js

@@ -204,6 +204,11 @@ export default class VelociousDatabaseMigrator {
 
     if (!environmentHandler || Object.keys(filteredDbs).length == 0) return
 
+    // Ensure velocious' own framework schema (background jobs) before the structure
+    // dump, and unconditionally — the dump is gated to enabled environments but the
+    // framework schema must exist after every migrate so `db:migrate` (and thus
+    // schema:load of the dumped SQL) produces a complete DB in every environment.
+    await environmentHandler.ensureFrameworkSchema({dbs: filteredDbs})
     await environmentHandler.afterMigrations({dbs: filteredDbs})
   }
 

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

@@ -130,6 +130,35 @@ export default class DataCopier {
    * @returns {Promise<Map<string, Record<string, unknown>[]>>} - Loaded rows grouped by table name.
    */
   async loadRows(db, keyValue) {
+    return (await this.traversePlan(db, keyValue)).rowsByTableName
+  }
+
+  /**
+   * Loads only the ids for `keyValue` for every table in the plan from `db`, using the same
+   * parent/child traversal as {@link DataCopier#loadRows} but selecting just the id column.
+   * Callers that only need to compare row membership — for example verifying a tenant already
+   * holds every default row before a cleanup delete — should use this instead of loadRows so
+   * they never materialise full rows; for large tenants that is the difference between a few
+   * kilobytes of ids and gigabytes of row data.
+   * @param {import("../drivers/base.js").default} db - Source or target database to traverse.
+   * @param {string} keyValue - Tenant key selecting the root plan rows.
+   * @returns {Promise<Map<string, string[]>>} - Loaded ids grouped by table name.
+   */
+  async loadRowIds(db, keyValue) {
+    return (await this.traversePlan(db, keyValue, [this.idColumn])).idsByTableName
+  }
+
+  /**
+   * Traverses the table plan for `keyValue`, querying each table by its tenant key column or
+   * (for child tables) by the ids already selected for its parent, and returns both the ids
+   * and the loaded rows grouped by table name. `selectColumns` bounds the columns each query
+   * selects; pass `[idColumn]` for an id-only traversal, or omit it to load full rows.
+   * @param {import("../drivers/base.js").default} db - Source or target database to traverse.
+   * @param {string} keyValue - Tenant key selecting the root plan rows.
+   * @param {string[]} [selectColumns] - Columns to select; defaults to every column.
+   * @returns {Promise<{idsByTableName: Map<string, string[]>, rowsByTableName: Map<string, Record<string, unknown>[]>}>} - Ids and rows grouped by table name.
+   */
+  async traversePlan(db, keyValue, selectColumns) {
     /** @type {Map<string, string[]>} */
     const idsByTableName = new Map()
     /** @type {Map<string, Record<string, unknown>[]>} */
@@ -142,6 +171,7 @@ export default class DataCopier {
         rows = await this.queryRowsByColumn({
           columnName: tableConfig.keyColumn,
           db,
+          selectColumns,
           tableName: tableConfig.tableName,
           values: [keyValue]
         })
@@ -157,6 +187,7 @@ export default class DataCopier {
         rows = await this.queryRowsByColumn({
           columnName: tableConfig.parentColumn,
           db,
+          selectColumns,
           tableName: tableConfig.tableName,
           values: idsByTableName.get(tableConfig.parentTableName) || []
         })
@@ -170,15 +201,16 @@ export default class DataCopier {
       rowsByTableName.set(tableConfig.tableName, rows)
     }
 
-    return rowsByTableName
+    return {idsByTableName, rowsByTableName}
   }
 
   /**
-   * Selects all rows of `tableName` in `db` whose `columnName` is in `values`, chunked.
-   * @param {{columnName: string, db: import("../drivers/base.js").default, tableName: string, values: string[]}} args - Table, column, database, and values for the chunked lookup.
+   * Selects `tableName` rows in `db` whose `columnName` is in `values`, chunked. `selectColumns`
+   * bounds the projection and defaults to every column.
+   * @param {{columnName: string, db: import("../drivers/base.js").default, selectColumns?: string[], tableName: string, values: string[]}} args - Table, column, projection, database, and values for the chunked lookup.
    * @returns {Promise<Record<string, unknown>[]>} - Rows matching the supplied column values.
    */
-  async queryRowsByColumn({columnName, db, tableName, values}) {
+  async queryRowsByColumn({columnName, db, selectColumns, tableName, values}) {
     const normalizedValues = uniqueStrings(values)
 
     if (normalizedValues.length <= 0) {
@@ -188,9 +220,12 @@ export default class DataCopier {
     const rows = []
     const quotedTable = db.quoteTable(tableName)
     const quotedColumn = db.quoteColumn(columnName)
+    const selectList = selectColumns
+      ? selectColumns.map((column) => `${quotedTable}.${db.quoteColumn(column)}`).join(", ")
+      : `${quotedTable}.*`
 
     for (const valuesChunk of chunks(normalizedValues, this.queryChunkSize)) {
-      const sql = `SELECT ${quotedTable}.* FROM ${quotedTable} WHERE ${quotedColumn} IN (${this.quotedValuesSql(db, valuesChunk)})`
+      const sql = `SELECT ${selectList} FROM ${quotedTable} WHERE ${quotedColumn} IN (${this.quotedValuesSql(db, valuesChunk)})`
 
       rows.push(...await this.executeQuietQuery(db, sql))
     }

package/src/environment-handlers/base.js

@@ -508,6 +508,20 @@ export default class VelociousEnvironmentHandlerBase {
     return
   }
 
+  /**
+   * Ensures velocious' own framework-owned schema (e.g. the background-jobs
+   * tables) exists after app migrations run, so `db:migrate` produces a complete
+   * schema deterministically instead of it only appearing once a runtime store
+   * boots. Runs before the structure dump. No-op by default; the node handler
+   * overrides it.
+   * @param {object} args - Options object.
+   * @param {Record<string, import("../database/drivers/base.js").default>} args.dbs - Dbs being migrated.
+   * @returns {Promise<void>} - Resolves when complete.
+   */
+  async ensureFrameworkSchema(args) { // eslint-disable-line no-unused-vars
+    return
+  }
+
   /**
    * Runs require command.
    * @abstract

package/src/environment-handlers/node.js

@@ -1005,6 +1005,29 @@ export default class VelociousEnvironmentHandlerNode extends Base{
     return basePath
   }
 
+  /**
+   * Ensures velocious' background-jobs schema exists on its configured database
+   * as part of `db:migrate`, so the framework's own tables (background_jobs +
+   * background_job_concurrency, execution_mode etc.) are created deterministically
+   * alongside app migrations and captured in the dumped structure SQL — rather than
+   * only appearing once a runtime store boots. Reuses the store's idempotent
+   * `_ensureSchema`, so it's safe to re-run against DBs that already have it.
+   * @param {object} args - Options object.
+   * @param {Record<string, import("../database/drivers/base.js").default>} args.dbs - Dbs being migrated.
+   * @returns {Promise<void>} - Resolves when complete.
+   */
+  async ensureFrameworkSchema({dbs}) {
+    const {default: BackgroundJobsStore} = await import("../background-jobs/store.js")
+    const store = new BackgroundJobsStore({configuration: this.getConfiguration()})
+    const databaseIdentifier = store.getDatabaseIdentifier() ?? "default"
+
+    // Reuse the connection db:migrate already holds for this database; opening a
+    // nested checkout would deadlock a database whose pool is capped at one
+    // connection. When the background-jobs database isn't among the migrated set,
+    // this passes undefined and the store checks out its own (that pool is free).
+    await store.ensureSchema(dbs[databaseIdentifier])
+  }
+
   /**
    * Runs after migrations.
    * @param {object} args - Options object.