velocious 1.0.579 → 1.0.581

package/src/environment-handlers/node/cli/commands/db/schema/dump.js

@@ -1,4 +1,6 @@
 import BaseCommand from "../../../../../../cli/base-command.js"
+import commandArguments from "../../../../../../cli/command-arguments.js"
+import DatabaseGenerationContext from "../../../../../../database/generation-context.js"
 import fileExists from "../../../../../../utils/file-exists.js"
 import path from "path"
 
@@ -8,6 +10,29 @@ export default class DbSchemaDump extends BaseCommand {
    * Runs execute.
    * @returns {Promise<void>} */
   async execute() {
+    const parsedArguments = commandArguments({
+      definition: {valueOptions: ["--tenant"]},
+      processArgs: this.processArgs || []
+    })
+    const tenantDatabaseIdentifier = parsedArguments.tenant
+
+    if (typeof tenantDatabaseIdentifier === "string") {
+      const context = await DatabaseGenerationContext.resolve({
+        configuration: this.getConfiguration(),
+        databaseIdentifier: tenantDatabaseIdentifier
+      })
+
+      await context.run({name: "DB selected tenant schema dump", callback: async (db) => {
+        const dbs = {[context.databaseIdentifier()]: db}
+        const shouldGenerate = await this.shouldGenerateStructureSql({dbs})
+
+        if (!shouldGenerate) return
+
+        await this.getEnvironmentHandler().afterMigrations({dbs, reason: "schemaDump"})
+      }})
+      return
+    }
+
     await this.getConfiguration().ensureConnections({name: "DB schema dump"}, async (dbs) => {
       const shouldGenerate = await this.shouldGenerateStructureSql({dbs})
 

package/src/environment-handlers/node/cli/commands/db/schema/load.js

@@ -1,4 +1,6 @@
 import BaseCommand from "../../../../../../cli/base-command.js"
+import commandArguments from "../../../../../../cli/command-arguments.js"
+import DatabaseGenerationContext from "../../../../../../database/generation-context.js"
 import fs from "fs/promises"
 import path from "path"
 import StructureSqlLoader from "../../../../../../database/structure-sql-loader.js"
@@ -9,17 +11,44 @@ export default class DbSchemaLoad extends BaseCommand {
    * Runs execute.
    * @returns {Promise<void>} */
   async execute() {
-    await this.getConfiguration().ensureConnections({name: "DB schema load"}, async (dbs) => {
-      const dbDir = path.join(this.directory(), "db")
-      const loader = new StructureSqlLoader()
+    const parsedArguments = commandArguments({
+      definition: {valueOptions: ["--tenant"]},
+      processArgs: this.processArgs || []
+    })
+    const tenantDatabaseIdentifier = parsedArguments.tenant
 
-      for (const identifier of Object.keys(dbs)) {
-        const db = dbs[identifier]
-        const structureFilePath = path.join(dbDir, `structure-${identifier}.sql`)
-        const structureSql = await fs.readFile(structureFilePath, "utf8")
+    if (typeof tenantDatabaseIdentifier === "string") {
+      const context = await DatabaseGenerationContext.resolve({
+        configuration: this.getConfiguration(),
+        databaseIdentifier: tenantDatabaseIdentifier
+      })
 
-        await loader.load({db, structureSql})
+      await context.run({name: "DB selected tenant schema load", callback: async (db) => {
+        await this.loadStructureSql({db, identifier: context.databaseIdentifier()})
+      }})
+      return
+    }
+
+    await this.getConfiguration().ensureConnections({name: "DB schema load"}, async (dbs) => {
+      for (const identifier of Object.keys(dbs)) {
+        await this.loadStructureSql({db: dbs[identifier], identifier})
       }
     })
   }
+
+  /**
+   * Loads one identifier's explicit structure file into one selected connection.
+   * @param {object} args - Load arguments.
+   * @param {import("../../../../../../database/drivers/base.js").default} args.db - Target connection.
+   * @param {string} args.identifier - Logical database identifier used in the file name.
+   * @returns {Promise<void>} - Resolves after loading.
+   */
+  async loadStructureSql({db, identifier}) {
+    const dbDir = path.join(this.directory(), "db")
+    const loader = new StructureSqlLoader()
+    const structureFilePath = path.join(dbDir, `structure-${identifier}.sql`)
+    const structureSql = await fs.readFile(structureFilePath, "utf8")
+
+    await loader.load({db, structureSql})
+  }
 }

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

@@ -1,6 +1,8 @@
 // @ts-check
 
 import BaseCommand from "../../../../../cli/base-command.js"
+import commandArguments from "../../../../../cli/command-arguments.js"
+import DatabaseGenerationContext from "../../../../../database/generation-context.js"
 import deburrColumnName from "../../../../../utils/deburr-column-name.js"
 import fileExists from "../../../../../utils/file-exists.js"
 import fs from "fs/promises"
@@ -62,15 +64,64 @@ function generatedRelationshipMethod({abstract = false, body, name, param, retur
 
 export default class DbGenerateModel extends BaseCommand {
   async execute() {
+    const parsedArguments = commandArguments({
+      definition: {
+        booleanOptions: ["--allow-missing-tables"],
+        valueOptions: ["--tenant"]
+      },
+      processArgs: this.processArgs || []
+    })
+    const allowMissingTables = parsedArguments["allow-missing-tables"] === true
+    const tenantDatabaseIdentifier = parsedArguments.tenant
+
+    if (typeof tenantDatabaseIdentifier === "string") {
+      const context = await DatabaseGenerationContext.resolve({
+        configuration: this.getConfiguration(),
+        databaseIdentifier: tenantDatabaseIdentifier
+      })
+      const selectedModelClasses = Object.values(this.getConfiguration().getModelClasses()).filter((modelClass) => {
+        const databaseIdentifier = modelClass.getDatabaseIdentifier({
+          enforceTenantDatabaseScope: false,
+          tenant: context.tenant()
+        })
+
+        if (databaseIdentifier !== context.databaseIdentifier()) return false
+
+        return modelClass.getDatabaseIdentifier({tenant: context.tenant()}) === context.databaseIdentifier()
+      })
+
+      try {
+        return await context.run({name: "Generate selected tenant base models", callback: async (connection) => {
+          await this.generateBaseModels({allowMissingTables, connections: {[context.databaseIdentifier()]: connection}, context})
+        }})
+      } finally {
+        for (const modelClass of selectedModelClasses) modelClass.resetRecordMetadata()
+      }
+    }
+
     await this.getConfiguration().initializeModels()
 
-    const enforceTenantDatabaseScopes = this.getConfiguration().getEnforceTenantDatabaseScopes()
+    return await this.getConfiguration().ensureConnections({name: "Generate base models"}, async (connections) => {
+      await this.generateBaseModels({allowMissingTables, connections})
+    })
+  }
 
+  /**
+   * Generates model bases from explicit connections.
+   * @param {object} args - Generation arguments.
+   * @param {boolean} args.allowMissingTables - Whether absent tables are skipped.
+   * @param {Record<string, import("../../../../../database/drivers/base.js").default>} args.connections - Connections keyed by logical identifier.
+   * @param {DatabaseGenerationContext} [args.context] - Selected tenant database context.
+   * @returns {Promise<void>} - Resolves after writing generated bases.
+   */
+  async generateBaseModels({allowMissingTables, connections, context}) {
     const rootDirectory = this.directory()
     const modelsDir = `${rootDirectory}/src/models`
     const baseModelsDir = `${rootDirectory}/src/model-bases`
     const modelClasses = this.getConfiguration().getModelClasses()
-    const allowMissingTables = Boolean(this.processArgs?.includes("--allow-missing-tables"))
+    const regenerateCommand = context
+      ? `${BASE_MODELS_REGENERATE_COMMAND} --tenant ${context.databaseIdentifier()}`
+      : BASE_MODELS_REGENERATE_COMMAND
     let devMode = false
 
     if (baseModelsDir.includes("/spec/dummy/src/model-bases")) {
@@ -81,13 +132,33 @@ export default class DbGenerateModel extends BaseCommand {
       await fs.mkdir(baseModelsDir, {recursive: true})
     }
 
-    this.getConfiguration().setEnforceTenantDatabaseScopes(false)
-
-    try {
-      await this.getConfiguration().ensureConnections({name: "Generate base models"}, async () => {
-        for (const modelClassName in modelClasses) {
+    for (const modelClassName in modelClasses) {
         const modelClass = modelClasses[modelClassName]
-        const table = await modelClass.connection().getTableByName(modelClass.tableName(), {throwError: !allowMissingTables})
+        let databaseIdentifier
+
+        if (context) {
+          databaseIdentifier = modelClass.getDatabaseIdentifier({
+            enforceTenantDatabaseScope: false,
+            tenant: context.tenant()
+          })
+
+          if (databaseIdentifier !== context.databaseIdentifier()) continue
+
+          databaseIdentifier = modelClass.getDatabaseIdentifier({tenant: context.tenant()})
+        } else {
+          databaseIdentifier = modelClass.getConfiguredDatabaseIdentifier()
+        }
+
+        if (context && databaseIdentifier !== context.databaseIdentifier()) continue
+
+        const connection = connections[databaseIdentifier]
+
+        // Default generation continues to ignore inactive tenant-only identifiers.
+        if (!connection) continue
+
+        if (context) modelClass.resetRecordMetadata()
+
+        const table = await connection.getTableByName(modelClass.tableName(), {throwError: !allowMissingTables})
 
         if (!table) {
           console.warn(`Skipping base model for '${modelClass.name}': table '${modelClass.tableName()}' was not found (--allow-missing-tables). Keeping any existing base model.`)
@@ -95,6 +166,8 @@ export default class DbGenerateModel extends BaseCommand {
           continue
         }
 
+        await modelClass.ensureInitialized({configuration: this.getConfiguration(), connection})
+
         const modelName = inflection.dasherize(modelClassName)
         const modelNameCamelized = inflection.camelize(modelName.replaceAll("-", "_"))
         const modelBaseFileName = `${inflection.dasherize(inflection.underscore(modelName))}.js`
@@ -111,7 +184,7 @@ export default class DbGenerateModel extends BaseCommand {
           sourceModelFilePath = "velocious/build/src/database/record/index.js"
         }
 
-        let fileContent = generatedFileBanner(BASE_MODELS_REGENERATE_COMMAND)
+        let fileContent = generatedFileBanner(regenerateCommand)
         let velociousPath
 
         if (devMode) {
@@ -454,10 +527,6 @@ export default class DbGenerateModel extends BaseCommand {
       fileContent += "}\n"
 
         await fs.writeFile(modelPath, fileContent)
-        }
-      })
-    } finally {
-      this.getConfiguration().setEnforceTenantDatabaseScopes(enforceTenantDatabaseScopes)
     }
   }