velocious 1.0.557 → 1.0.559

package/src/tenants/tenant.js

@@ -11,19 +11,21 @@ import TenantIterator from "./tenant-iterator.js"
  * class is the single discoverable home for switching into a tenant's context, reading the
  * current one, iterating every tenant of a database identifier, and dropping a tenant's
  * database. Switching delegates to {@link Current} (which owns the async-context tenant
- * state) and additionally runs the callback inside `ensureConnections`, so entering a tenant
+ * state) and additionally runs the callback inside `ensureConnections`, initializing registered
+ * tenant-switched models whose tables exist before the callback runs. Entering a tenant therefore
  * makes its database immediately queryable — the apartment-style "switch" semantics — without
- * the caller establishing connections itself; iteration and drop drive the app's tenant
- * database provider hooks.
+ * the caller establishing connections or model metadata itself; iteration and drop drive the
+ * app's tenant database provider hooks.
  */
 export default class Tenant {
   /**
    * Runs `callback` with `tenant` as the current tenant, restoring the previous tenant after.
    * The callback runs inside `ensureConnections`, so every database identifier the tenant
    * activates (the global database plus the tenant's database) has a checked-out connection
-   * available for the callback's duration: switching into a tenant makes it queryable without
-   * the caller wiring up connections. Already-checked-out connections are reused, so nesting
-   * `Tenant.with` calls does not open redundant connections. The callback receives the active
+   * available for the callback's duration. Registered tenant-switched models whose tables exist
+   * are initialized before the callback runs, so switching into a tenant makes it queryable
+   * without the caller wiring up connections or model metadata. Already-checked-out connections
+   * and in-progress model initialization promises are reused. The callback receives the active
    * connections keyed by identifier, the same as `ensureConnections`.
    * @template T
    * @param {object} tenant Descriptor understood by the app's tenantDatabaseResolver.
@@ -33,7 +35,41 @@ export default class Tenant {
   static async with(tenant, callback) {
     const configuration = Current.configuration()
 
-    return await Current.withTenant(tenant, async () => await configuration.ensureConnections(callback))
+    return await Current.withTenant(tenant, async () => await configuration.ensureConnections(async (connections) => {
+      await this._ensureCurrentTenantModelsInitialized(configuration)
+
+      return await callback(connections)
+    }))
+  }
+
+  /**
+   * Initializes registered tenant-switched models whose tables exist in the
+   * current tenant before runtime callbacks can build synchronous query scopes.
+   * Models for absent optional tables remain deferred until they are used.
+   * @param {import("../configuration.js").default} configuration - Current configuration.
+   * @returns {Promise<void>} - Resolves when available tenant models are initialized.
+   */
+  static async _ensureCurrentTenantModelsInitialized(configuration) {
+    for (const modelClass of Object.values(configuration.getModelClasses())) {
+      if (modelClass.isInitialized() || !modelClass.hasTenantDatabaseIdentifierResolver()) continue
+
+      const databaseIdentifier = modelClass.getTenantDatabaseIdentifier()
+
+      if (!databaseIdentifier || !configuration.isDatabaseIdentifierActive(databaseIdentifier)) continue
+
+      const connection = modelClass.connection()
+      const table = await connection.getTableByName(modelClass.tableName(), {throwError: false})
+
+      if (!table) continue
+
+      if (Object.keys(modelClass.getTranslationsMap()).length > 0) {
+        const translationsTable = await connection.getTableByName(modelClass.getTranslationsTableName(), {throwError: false})
+
+        if (!translationsTable) continue
+      }
+
+      await modelClass.ensureInitialized({configuration})
+    }
   }
 
   /**
@@ -47,9 +83,10 @@ export default class Tenant {
   /**
    * Lists the tenants for a database identifier through the provider and runs `callback`
    * within each tenant's context, optionally filtered and several at a time. Like
-   * {@link Tenant.with}, the callback runs inside `ensureConnections` so each tenant's
-   * database is queryable without the caller wiring up connections. Returns how many tenants
-   * the callback ran for (after filtering).
+   * {@link Tenant.with}, the callback runs inside `ensureConnections` after available
+   * tenant-switched models are initialized, so each tenant's database is queryable without the
+   * caller wiring up connections or model metadata. Returns how many tenants the callback ran
+   * for (after filtering).
    * @param {{identifier: string, callback: function({databaseConfiguration: import("../configuration-types.js").DatabaseConfigurationType, tenant: ?}) : Promise<void>, parallel?: number, filter?: (tenant: ?) => boolean, configuration?: import("../configuration.js").default}} args - Tenant database identifier, per-tenant operation, filtering, and concurrency settings.
    * @returns {Promise<number>} - Number of processed tenants.
    */
@@ -71,7 +108,10 @@ export default class Tenant {
     // their callbacks, such as create, before the tenant database exists) while runtime
     // iteration here gets the tenant's connections established the same way Tenant.with does.
     return await iterator.run(tenants, async (callbackArgs) => {
-      await configuration.ensureConnections({name: `Tenant.each: ${identifier}`}, async () => await callback(callbackArgs))
+      await configuration.ensureConnections({name: `Tenant.each: ${identifier}`}, async () => {
+        await this._ensureCurrentTenantModelsInitialized(configuration)
+        await callback(callbackArgs)
+      })
     })
   }
 

package/src/testing/factory/factory-registry.js

@@ -333,17 +333,27 @@ export default class FactoryRegistry {
     const {traits, overrides} = normalizeInvocationArgs(args)
     /** @type {Array<?>} */
     const results = []
+    /** @type {import("./factory-runner.js").CompiledPlan | undefined} */
+    let planTemplate
 
-    for (let index = 0; index < count; index++) {
-      results.push(await this._runFactory({factoryName, traits, overrides, strategy}))
+    this._activeEvaluations += 1
+
+    try {
+      for (let index = 0; index < count; index++) {
+        const invocation = await this._runFactoryInvocation({factoryName, traits, overrides, strategy, planTemplate})
+
+        planTemplate = invocation.planTemplate
+        results.push(invocation.result)
+      }
+    } finally {
+      this._activeEvaluations -= 1
     }
 
     return results
   }
 
   /**
-   * Compiles and runs a factory invocation under a strategy, tracking active
-   * evaluations for the mutation guard.
+   * Compiles and runs a factory invocation under a strategy.
    * @param {object} args - Options.
    * @param {string} args.factoryName - Factory name.
    * @param {string[]} args.traits - Ordered traits.
@@ -351,7 +361,21 @@ export default class FactoryRegistry {
    * @param {"attributesFor" | "build" | "create"} args.strategy - Strategy name.
    * @returns {Promise<?>} - The strategy result.
    */
-  async _runFactory({factoryName, traits, overrides, strategy}) {
+  async _runFactory(args) {
+    return (await this._runFactoryInvocation(args)).result
+  }
+
+  /**
+   * Runs one event-tracked invocation, optionally reusing declaration planning.
+   * @param {object} args - Options.
+   * @param {string} args.factoryName - Factory name.
+   * @param {string[]} args.traits - Ordered traits.
+   * @param {Record<string, ?>} args.overrides - Overrides.
+   * @param {"attributesFor" | "build" | "create"} args.strategy - Strategy name.
+   * @param {import("./factory-runner.js").CompiledPlan} [args.planTemplate] - Reusable declaration plan.
+   * @returns {Promise<{result: ?, planTemplate: import("./factory-runner.js").CompiledPlan}>} - Result and declaration plan.
+   */
+  async _runFactoryInvocation({factoryName, traits, overrides, strategy, planTemplate}) {
     this._activeEvaluations += 1
 
     const invocationId = this._events.nextInvocationId()
@@ -360,12 +384,13 @@ export default class FactoryRegistry {
     try {
       this._events.emit("start", {invocationId, factory: factoryName, strategy, traits})
 
-      const plan = this._runner.compile(factoryName, traits, overrides)
-      const result = await this._strategies[strategy].run({registry: this, plan})
+      const compiledPlanTemplate = planTemplate || this._runner.compileTemplate(factoryName, traits)
+      const compiledPlan = this._runner.applyOverrides(compiledPlanTemplate, overrides)
+      const result = await this._strategies[strategy].run({registry: this, plan: compiledPlan})
 
       this._events.emit("success", {invocationId, factory: factoryName, strategy, traits, durationMs: Date.now() - startedAt})
 
-      return result
+      return {result, planTemplate: compiledPlanTemplate}
     } catch (error) {
       this._events.emit("failure", {invocationId, factory: factoryName, strategy, traits, durationMs: Date.now() - startedAt, error})
 

package/src/testing/factory/factory-runner.js

@@ -48,6 +48,16 @@ export default class FactoryRunner {
    * @returns {CompiledPlan} - The compiled plan.
    */
   compile(factoryName, requestedTraits, overrides) {
+    return this.applyOverrides(this.compileTemplate(factoryName, requestedTraits), overrides)
+  }
+
+  /**
+   * Compiles inheritance, traits and declarations without call-site overrides.
+   * @param {string} factoryName - Factory to run.
+   * @param {string[]} requestedTraits - Traits requested at the call site, in order.
+   * @returns {CompiledPlan} - Reusable declaration plan.
+   */
+  compileTemplate(factoryName, requestedTraits) {
     const chain = this._resolveChain(factoryName)
     const target = chain[chain.length - 1]
     const modelClass = this._resolveModelClass(chain)
@@ -67,7 +77,31 @@ export default class FactoryRunner {
       this._expandTrait(traitName, target, flattened, [])
     }
 
-    return this._buildPlan({flattened, overrides, modelClass, target, chainNames: chain.map((definition) => definition.name)})
+    return this._buildPlan({flattened, modelClass, target, chainNames: chain.map((definition) => definition.name)})
+  }
+
+  /**
+   * Applies the current call-site overrides without mutating the reusable template.
+   * @param {CompiledPlan} planTemplate - Reusable declaration plan.
+   * @param {Record<string, ?>} overrides - Current call-site overrides.
+   * @returns {CompiledPlan} - Per-invocation plan.
+   */
+  applyOverrides(planTemplate, overrides) {
+    const overrideKeys = Object.keys(overrides)
+
+    if (overrideKeys.length === 0) return planTemplate
+
+    const resolved = new Map(planTemplate.resolved)
+
+    for (const key of overrideKeys) {
+      const prior = resolved.get(key)
+
+      resolved.set(key, {slotKind: prior ? prior.slotKind : "attribute", value: overrides[key], isOverride: true})
+    }
+
+    this._arbitrateAssociationOverrides(resolved, overrides, planTemplate.modelClass)
+
+    return {...planTemplate, resolved}
   }
 
   /**
@@ -193,16 +227,15 @@ export default class FactoryRunner {
   }
 
   /**
-   * Folds flattened declarations plus overrides into a compiled plan.
+   * Folds flattened declarations into a reusable compiled plan.
    * @param {object} args - Options.
    * @param {Array<{decl: import("./declarations.js").Declaration}>} args.flattened - Flattened declarations.
-   * @param {Record<string, ?>} args.overrides - Call-site overrides.
    * @param {(new (attributes?: Record<string, ?>) => ?) | null} args.modelClass - Resolved model class.
    * @param {import("./factory-definition.js").default} args.target - Target factory definition.
    * @param {string[]} args.chainNames - Inheritance chain names.
    * @returns {CompiledPlan} - The compiled plan.
    */
-  _buildPlan({flattened, overrides, modelClass, target, chainNames}) {
+  _buildPlan({flattened, modelClass, target, chainNames}) {
     /** @type {Map<string, Slot>} */
     const resolved = new Map()
     /** @type {Map<string, import("./declarations.js").CallbackDeclaration[]>} */
@@ -238,14 +271,6 @@ export default class FactoryRunner {
       }
     }
 
-    for (const key of Object.keys(overrides)) {
-      const prior = resolved.get(key)
-
-      resolved.set(key, {slotKind: prior ? prior.slotKind : "attribute", value: overrides[key], isOverride: true})
-    }
-
-    this._arbitrateAssociationOverrides(resolved, overrides, modelClass)
-
     return {
       factoryName: target.name,
       factoryDefinition: target,
@@ -269,6 +294,7 @@ export default class FactoryRunner {
    * @returns {void}
    */
   _arbitrateAssociationOverrides(resolved, overrides, modelClass) {
+    if (Object.keys(overrides).length === 0) return
     if (typeof modelClass !== "function" || !(modelClass.prototype instanceof DatabaseRecord)) return
 
     const backendModelClass = /** @type {typeof DatabaseRecord} */ (modelClass)

package/src/utils/shutdown-lifecycle.js

@@ -0,0 +1,41 @@
+// @ts-check
+
+/**
+ * Runs service shutdown and its completion hook while preserving both failures.
+ * @param {object} args - Lifecycle callbacks.
+ * @param {() => Promise<void>} args.shutdown - Primary service shutdown.
+ * @param {() => void | Promise<void>} [args.onStopped] - Completion hook.
+ * @returns {Promise<void>} - Resolves after shutdown and the hook finish.
+ */
+export default async function shutdownLifecycle({shutdown, onStopped}) {
+  let shutdownFailed = false
+  let shutdownError
+
+  try {
+    await shutdown()
+  } catch (error) {
+    shutdownFailed = true
+    shutdownError = error
+  }
+
+  let hookFailed = false
+  let hookError
+
+  try {
+    await onStopped?.()
+  } catch (error) {
+    hookFailed = true
+    hookError = error
+  }
+
+  if (shutdownFailed && hookFailed) {
+    throw new AggregateError(
+      [shutdownError, hookError],
+      "Service shutdown and onStopped hook failed",
+      {cause: shutdownError}
+    )
+  }
+
+  if (hookFailed) throw hookError
+  if (shutdownFailed) throw shutdownError
+}