velocious 1.0.580 → 1.0.581

package/README.md

@@ -8,6 +8,7 @@
 * Built-in record auditing for model lifecycle changes (see [docs/auditing.md](docs/auditing.md))
 * Declarative state machines for models, with typed event methods generated into the base model (see [docs/state-machine.md](docs/state-machine.md))
 * Migrations for schema changes and UTC datetime storage (see [docs/database-migrations.md](docs/database-migrations.md))
+* Tenant-selected base-model and structure generation with one immutable, fail-closed physical database context; tenant-only model metadata initializes only after that context is active (see [docs/tenant-selected-database-generation.md](docs/tenant-selected-database-generation.md))
 * External packages (engines) that contribute data models, frontend-model resources and migrations to a consuming app (see [docs/packages.md](docs/packages.md))
 * Optional Rampway-owned durable deployment control plane mounted through the standard routes DSL on Velocious 1.0.577 or newer (see [docs/rampway-integration.md](docs/rampway-integration.md))
 * Controllers and views for HTTP endpoints

package/build/cli/command-arguments.js

@@ -0,0 +1,45 @@
+// @ts-check
+
+/**
+ * @typedef {object} CommandArgumentDefinition
+ * @property {string[]} [booleanOptions] - Flags that do not accept a value.
+ * @property {string[]} [valueOptions] - Flags that require one value.
+ */
+
+/**
+ * Parses and validates one command's arguments.
+ * @param {object} args - Parser arguments.
+ * @param {CommandArgumentDefinition} args.definition - Accepted command options.
+ * @param {string[]} args.processArgs - Raw command arguments including the command name.
+ * @returns {Record<string, string | boolean>} - Values keyed by long option name without `--`.
+ */
+export default function commandArguments({definition, processArgs}) {
+  const commandName = processArgs[0] || "command"
+  const booleanOptions = new Set(definition.booleanOptions || [])
+  const valueOptions = new Set(definition.valueOptions || [])
+  /** @type {Record<string, string | boolean>} */
+  const parsed = {}
+
+  for (let index = 1; index < processArgs.length; index++) {
+    const argument = processArgs[index]
+
+    if (booleanOptions.has(argument)) {
+      parsed[argument.slice(2)] = true
+      continue
+    }
+
+    if (valueOptions.has(argument)) {
+      const value = processArgs[index + 1]
+
+      if (!value || value.startsWith("-")) throw new Error(`Missing value for ${argument}`)
+
+      parsed[argument.slice(2)] = value
+      index++
+      continue
+    }
+
+    throw new Error(`Unknown argument for ${commandName}: ${argument}`)
+  }
+
+  return parsed
+}

package/build/cli/index.js

@@ -1,5 +1,7 @@
 // @ts-check
 
+const COMMAND_VALUE_OPTIONS = new Set(["--tenant"])
+
 export default class VelociousCli {
   /**
    * Runs constructor.
@@ -94,6 +96,7 @@ export default class VelociousCli {
      * Current group.
      * @type {string[]} */
     let currentGroup = []
+    let expectsOptionValue = false
 
     for (const processArg of processArgs) {
       if (currentGroup.length == 0) {
@@ -103,11 +106,18 @@ export default class VelociousCli {
         continue
       }
 
+      if (expectsOptionValue) {
+        currentGroup.push(processArg)
+        expectsOptionValue = false
+        continue
+      }
+
       if (!processArg.startsWith("-") && commandNames.has(processArg)) {
         groups.push(currentGroup)
         currentGroup = [processArg]
       } else {
         currentGroup.push(processArg)
+        expectsOptionValue = COMMAND_VALUE_OPTIONS.has(processArg)
       }
     }
 

package/build/configuration-types.js

@@ -661,6 +661,7 @@
 /**
  * @typedef {object} TenantDatabaseProviderType
  * @property {(args: {configuration: import("./configuration.js").default, identifier: string}) => Array<ReturnType<typeof JSON.parse>> | Promise<Array<ReturnType<typeof JSON.parse>>>} listTenants - Lists tenants that should be created, checked, or migrated for this database identifier.
+ * @property {(args: {configuration: import("./configuration.js").default, identifier: string}) => ReturnType<typeof JSON.parse> | void | Promise<ReturnType<typeof JSON.parse> | void>} [resolveGenerationTenant] - Resolves one explicit tenant descriptor for schema/base-model generation without enumerating lifecycle tenants.
  * @property {(args: {configuration: import("./configuration.js").default, identifier: string}) => Array<ReturnType<typeof JSON.parse>> | Promise<Array<ReturnType<typeof JSON.parse>>>} [listRestrictTenants] - Lists existing tenants that should be checked for dependent restrict destroys. Defaults to listTenants.
  * @property {(args: {configuration: import("./configuration.js").default, databaseConfiguration: DatabaseConfigurationType, identifier: string, tenant: ReturnType<typeof JSON.parse>}) => void | Promise<void>} [createDatabase] - Creates the tenant database/schema for one tenant.
  * @property {(args: {configuration: import("./configuration.js").default, databaseConfiguration: DatabaseConfigurationType, identifier: string, tenant: ReturnType<typeof JSON.parse>}) => void | Promise<void>} [dropDatabase] - Drops the tenant database/schema for one tenant.

package/build/database/generation-context.js

@@ -0,0 +1,121 @@
+// @ts-check
+
+import Tenant from "../tenants/tenant.js"
+
+/**
+ * Immutable selection of one logical tenant database and one provider-resolved
+ * physical tenant. Schema tools can share this contract without ambient or
+ * process-global selection state.
+ */
+export default class DatabaseGenerationContext {
+  /**
+   * Resolves one tenant-only database from its provider and captures its physical identity.
+   * @param {object} args - Selection arguments.
+   * @param {import("../configuration.js").default} args.configuration - Owning configuration.
+   * @param {string} args.databaseIdentifier - Logical tenant-only database identifier.
+   * @returns {Promise<DatabaseGenerationContext>} - Immutable selected database context.
+   */
+  static async resolve({configuration, databaseIdentifier}) {
+    const databaseConfiguration = configuration.getDatabaseConfiguration()[databaseIdentifier]
+
+    if (!databaseConfiguration) {
+      throw new Error(`No such tenant database identifier configured: ${databaseIdentifier}`)
+    }
+    if (!databaseConfiguration.tenantOnly) {
+      throw new Error(`Database identifier ${databaseIdentifier} is not configured with tenantOnly: true`)
+    }
+    if (configuration.getDisabledDatabaseIdentifiers().has(databaseIdentifier)) {
+      throw new Error(`Tenant database identifier ${databaseIdentifier} is disabled by VELOCIOUS_DISABLED_DATABASE_IDENTIFIERS`)
+    }
+
+    const provider = configuration.getTenantDatabaseProvider(databaseIdentifier)
+
+    await configuration.initialize({type: "database-generation"})
+
+    const tenants = await configuration.ensureConnections({name: `Resolve database generation context: ${databaseIdentifier}`}, async () => {
+      if (provider.resolveGenerationTenant) {
+        const tenant = await provider.resolveGenerationTenant({configuration, identifier: databaseIdentifier})
+
+        return tenant === undefined ? [] : [tenant]
+      }
+
+      return await provider.listTenants({configuration, identifier: databaseIdentifier})
+    })
+
+    if (!Array.isArray(tenants)) {
+      throw new Error(`Tenant database provider for ${databaseIdentifier} must return an array from listTenants`)
+    }
+    if (tenants.length === 0) {
+      throw new Error(`Tenant database selection ${databaseIdentifier} resolved no tenants`)
+    }
+    if (tenants.length !== 1) {
+      throw new Error(`Tenant database selection ${databaseIdentifier} is ambiguous: provider returned ${tenants.length} tenants`)
+    }
+
+    const tenant = tenants[0]
+
+    if (!tenant || typeof tenant !== "object" || Array.isArray(tenant)) {
+      throw new Error(`Tenant database selection ${databaseIdentifier} returned an invalid tenant descriptor`)
+    }
+
+    const handle = Tenant.handle(tenant, configuration)
+
+    // Resolve now so an inactive/stale descriptor fails before a selected
+    // schema connection can be checked out or read.
+    handle.databaseConfiguration(databaseIdentifier)
+
+    return new DatabaseGenerationContext({configuration, databaseIdentifier, handle})
+  }
+
+  /**
+   * Runs constructor.
+   * @param {object} args - Captured selection.
+   * @param {import("../configuration.js").default} args.configuration - Owning configuration.
+   * @param {string} args.databaseIdentifier - Logical database identifier.
+   * @param {ReturnType<typeof Tenant.handle>} args.handle - Captured tenant handle.
+   */
+  constructor({configuration, databaseIdentifier, handle}) {
+    this._configuration = configuration
+    this._databaseIdentifier = databaseIdentifier
+    this._handle = handle
+
+    Object.freeze(this)
+  }
+
+  /**
+   * Returns the captured logical database identifier.
+   * @returns {string} - Captured logical database identifier.
+   */
+  databaseIdentifier() { return this._databaseIdentifier }
+
+  /**
+   * Returns the captured physical database configuration.
+   * @returns {import("../configuration-types.js").DatabaseConfigurationType} - Captured physical database configuration.
+   */
+  databaseConfiguration() { return this._handle.databaseConfiguration(this._databaseIdentifier) }
+
+  /**
+   * Returns the captured tenant descriptor.
+   * @returns {ReturnType<ReturnType<typeof Tenant.handle>["tenant"]>} - Captured immutable tenant descriptor.
+   */
+  tenant() { return this._handle.tenant() }
+
+  /**
+   * Runs work on one connection pinned to the captured physical database.
+   * @template T
+   * @param {object} args - Work arguments.
+   * @param {(connection: import("./drivers/base.js").default) => Promise<T>} args.callback - Selected database work.
+   * @param {string} args.name - Checkout name.
+   * @returns {Promise<T>} - Callback result.
+   */
+  async run({callback, name}) {
+    return await this._configuration.runWithTenant(this.tenant(), async () => {
+      return await this._configuration.withDatabaseOperation({
+        databaseConfiguration: this.databaseConfiguration(),
+        databaseIdentifier: this.databaseIdentifier(),
+        name,
+        tenant: this.tenant()
+      }, async (operation) => await callback(operation.connection()))
+    })
+  }
+}

package/build/database/initializer-from-require-context.js

@@ -43,6 +43,13 @@ export default class VelociousDatabaseInitializerFromRequireContext {
 
       if (!modelClass) throw new Error(`Model wasn't exported from: ${fileName}`)
 
+      const configuredDatabase = configuration.getDatabaseConfiguration()[modelClass.getConfiguredDatabaseIdentifier()]
+
+      if (configuredDatabase?.tenantOnly && !configuration.isDatabaseIdentifierActive(modelClass.getConfiguredDatabaseIdentifier())) {
+        modelClass.registerRecordClass({configuration})
+        continue
+      }
+
       if (!modelClass.getEagerLoadRecordMetadata()) {
         modelClass.registerRecordClass({configuration})
         await this._bestEffortInitializeDeferredModel({configuration, modelClass})

package/build/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/build/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/build/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)
     }
   }
 

package/build/src/cli/command-arguments.d.ts

@@ -0,0 +1,27 @@
+export type CommandArgumentDefinition = {
+    /**
+     * - Flags that do not accept a value.
+     */
+    booleanOptions?: string[];
+    /**
+     * - Flags that require one value.
+     */
+    valueOptions?: string[];
+};
+/**
+ * @typedef {object} CommandArgumentDefinition
+ * @property {string[]} [booleanOptions] - Flags that do not accept a value.
+ * @property {string[]} [valueOptions] - Flags that require one value.
+ */
+/**
+ * Parses and validates one command's arguments.
+ * @param {object} args - Parser arguments.
+ * @param {CommandArgumentDefinition} args.definition - Accepted command options.
+ * @param {string[]} args.processArgs - Raw command arguments including the command name.
+ * @returns {Record<string, string | boolean>} - Values keyed by long option name without `--`.
+ */
+export default function commandArguments({ definition, processArgs }: {
+    definition: CommandArgumentDefinition;
+    processArgs: string[];
+}): Record<string, string | boolean>;
+//# sourceMappingURL=command-arguments.d.ts.map

package/build/src/cli/command-arguments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-arguments.d.ts","sourceRoot":"","sources":["../../../src/cli/command-arguments.js"],"names":[],"mappings":"AAGG,YAAkB,yBAAyB,GAC3C;;;;IAAsB,cAAc,AAApC,CACA,EADW,MAAM,EAAE,CACnB;;;;IAAsB,YAAY,AAAlC,CACF,EADa,MAAM,EAAE,CACrB;CAAA,CAAA;AAJD;;;;GAIG;AAEH;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,UAAU,gBAAgB,CAAC,EAAC,UAAU,EAAE,WAAW,EAAC,EAJ/D;IAAwC,UAAU,EAA1C,yBAAyB,CACjC;IAAuB,WAAW,EAA1B,MAAM,EAAE,CAChB;CAE+D,GAFrD,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,CA+B5C"}

package/build/src/cli/command-arguments.js

@@ -0,0 +1,38 @@
+// @ts-check
+/**
+ * @typedef {object} CommandArgumentDefinition
+ * @property {string[]} [booleanOptions] - Flags that do not accept a value.
+ * @property {string[]} [valueOptions] - Flags that require one value.
+ */
+/**
+ * Parses and validates one command's arguments.
+ * @param {object} args - Parser arguments.
+ * @param {CommandArgumentDefinition} args.definition - Accepted command options.
+ * @param {string[]} args.processArgs - Raw command arguments including the command name.
+ * @returns {Record<string, string | boolean>} - Values keyed by long option name without `--`.
+ */
+export default function commandArguments({ definition, processArgs }) {
+    const commandName = processArgs[0] || "command";
+    const booleanOptions = new Set(definition.booleanOptions || []);
+    const valueOptions = new Set(definition.valueOptions || []);
+    /** @type {Record<string, string | boolean>} */
+    const parsed = {};
+    for (let index = 1; index < processArgs.length; index++) {
+        const argument = processArgs[index];
+        if (booleanOptions.has(argument)) {
+            parsed[argument.slice(2)] = true;
+            continue;
+        }
+        if (valueOptions.has(argument)) {
+            const value = processArgs[index + 1];
+            if (!value || value.startsWith("-"))
+                throw new Error(`Missing value for ${argument}`);
+            parsed[argument.slice(2)] = value;
+            index++;
+            continue;
+        }
+        throw new Error(`Unknown argument for ${commandName}: ${argument}`);
+    }
+    return parsed;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/src/cli/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/cli/index.js"],"names":[],"mappings":"AAEA,MAAM,CAAC,OAAO,OAAO,YAAY;IAcxB,IAAI;wBAVA,OAAO,qBAAqB,EAAE,OAAO;oBACrC,MAAM;6BACN,OAAO,iCAAiC,EAAE,OAAO;4BACjD,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,SAAS,CAAC;sBACrD,MAAM,EAAE;kBACR,OAAO;;IAMX,aAAa;IAEb,kBAAkB;IAhBzB;;;;;;;;;OASG;IACH,YAAY,IAAI,GAPb;QAAqD,aAAa,AAAlE,CACA,EADQ,OAAO,qBAAqB,EAAE,OAAO,CAC7C;QAAsB,SAAS,AAA/B,CACA,EADQ,MAAM,CACd;QAAiE,kBAAkB,AAAnF,CACA,EADQ,OAAO,iCAAiC,EAAE,OAAO,CACzD;QAAqE,iBAAiB,AAAtF,CACA,EADQ,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,SAAS,CAAC,CAC7D;QAAwB,WAAW,AAAnC,CACA,EADQ,MAAM,EAAE,CAChB;QAAuB,OAAO,AAA9B,CACF,EADU,OAAO,CACjB;KACoB,EASpB;IAED;;;OAGG;IACG,OAAO,IAFA,OAAO,CAAC,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CAmBlD;IAED;;;;OAIG;IACG,cAAc,CAAC,WAAW,EAHrB,MAAM,EAGe,GAFnB,OAAO,CAAC,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CA4BlD;IAED;;;OAGG;IACG,aAAa,IAFN,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAwC/B;IAED;;;OAGG;IACH,gBAAgB,IAFH,OAAO,qBAAqB,EAAE,OAAO,CAEF;IAEhD;;;OAGG;IACH,6BAA6B,IAFhB,OAAO,CAUnB;IAED;;;OAGG;IACH,UAAU,IAFG,OAAO,CAInB;CACF"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/cli/index.js"],"names":[],"mappings":"AAIA,MAAM,CAAC,OAAO,OAAO,YAAY;IAcxB,IAAI;wBAVA,OAAO,qBAAqB,EAAE,OAAO;oBACrC,MAAM;6BACN,OAAO,iCAAiC,EAAE,OAAO;4BACjD,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,SAAS,CAAC;sBACrD,MAAM,EAAE;kBACR,OAAO;;IAMX,aAAa;IAEb,kBAAkB;IAhBzB;;;;;;;;;OASG;IACH,YAAY,IAAI,GAPb;QAAqD,aAAa,AAAlE,CACA,EADQ,OAAO,qBAAqB,EAAE,OAAO,CAC7C;QAAsB,SAAS,AAA/B,CACA,EADQ,MAAM,CACd;QAAiE,kBAAkB,AAAnF,CACA,EADQ,OAAO,iCAAiC,EAAE,OAAO,CACzD;QAAqE,iBAAiB,AAAtF,CACA,EADQ,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,SAAS,CAAC,CAC7D;QAAwB,WAAW,AAAnC,CACA,EADQ,MAAM,EAAE,CAChB;QAAuB,OAAO,AAA9B,CACF,EADU,OAAO,CACjB;KACoB,EASpB;IAED;;;OAGG;IACG,OAAO,IAFA,OAAO,CAAC,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CAmBlD;IAED;;;;OAIG;IACG,cAAc,CAAC,WAAW,EAHrB,MAAM,EAGe,GAFnB,OAAO,CAAC,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CA4BlD;IAED;;;OAGG;IACG,aAAa,IAFN,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAgD/B;IAED;;;OAGG;IACH,gBAAgB,IAFH,OAAO,qBAAqB,EAAE,OAAO,CAEF;IAEhD;;;OAGG;IACH,6BAA6B,IAFhB,OAAO,CAUnB;IAED;;;OAGG;IACH,UAAU,IAFG,OAAO,CAInB;CACF"}

package/build/src/cli/index.js

@@ -1,4 +1,5 @@
 // @ts-check
+const COMMAND_VALUE_OPTIONS = new Set(["--tenant"]);
 export default class VelociousCli {
     /**
      * Runs constructor.
@@ -85,6 +86,7 @@ export default class VelociousCli {
          * Current group.
          * @type {string[]} */
         let currentGroup = [];
+        let expectsOptionValue = false;
         for (const processArg of processArgs) {
             if (currentGroup.length == 0) {
                 if (processArg.startsWith("-"))
@@ -92,12 +94,18 @@ export default class VelociousCli {
                 currentGroup = [processArg];
                 continue;
             }
+            if (expectsOptionValue) {
+                currentGroup.push(processArg);
+                expectsOptionValue = false;
+                continue;
+            }
             if (!processArg.startsWith("-") && commandNames.has(processArg)) {
                 groups.push(currentGroup);
                 currentGroup = [processArg];
             }
             else {
                 currentGroup.push(processArg);
+                expectsOptionValue = COMMAND_VALUE_OPTIONS.has(processArg);
             }
         }
         if (currentGroup.length > 0) {
@@ -135,4 +143,4 @@ export default class VelociousCli {
         return this.args.testing || false;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/cli/index.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nexport default class VelociousCli {\n  /**\n   * Runs constructor.\n   * @param {object} args - Options object.\n   * @param {import(\"../configuration.js\").default} [args.configuration] - Configuration instance.\n   * @param {string} [args.directory] - Directory path.\n   * @param {import(\"../environment-handlers/base.js\").default} [args.environmentHandler] - Environment handler.\n   * @param {Record<string, string | number | boolean | undefined>} [args.parsedProcessArgs] - Parsed process args.\n   * @param {string[]} [args.processArgs] - Process args.\n   * @param {boolean} [args.testing] - Whether testing.\n   */\n  constructor(args = {}) {\n    if (!args.configuration) throw new Error(\"configuration argument is required\")\n\n    this.args = args\n    this.configuration = args.configuration\n\n    this.environmentHandler = args.configuration.getEnvironmentHandler()\n    this.environmentHandler.setArgs(args)\n    this.environmentHandler.setConfiguration(args.configuration)\n  }\n\n  /**\n   * Runs execute.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - Resolves with the final command result.\n   */\n  async execute() {\n    const commandGroups = await this.commandGroups()\n    let result\n\n    for (const commandProcessArgs of commandGroups) {\n      const shouldCloseDatabaseConnections = !this.hasCurrentDatabaseConnections()\n\n      try {\n        result = await this.executeCommand(commandProcessArgs)\n      } finally {\n        if (shouldCloseDatabaseConnections) {\n          await this.getConfiguration().closeDatabaseConnections()\n        }\n      }\n    }\n\n    return result\n  }\n\n  /**\n   * Runs execute command.\n   * @param {string[]} processArgs - Process args for a single command.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - Resolves with the command result.\n   */\n  async executeCommand(processArgs) {\n    if (!processArgs[0]) {\n      throw new Error(\"Missing command argument\")\n    }\n\n    const commandParts = processArgs[0].split(\":\")\n    const parsedCommandParts = []\n\n    for (let commandPart of commandParts) {\n      if (commandPart == \"c\") commandPart = \"console\"\n      if (commandPart == \"d\") commandPart = \"destroy\"\n      if (commandPart == \"g\") commandPart = \"generate\"\n      if (commandPart == \"s\") commandPart = \"server\"\n\n      parsedCommandParts.push(commandPart)\n    }\n\n    const CommandClass = await this.environmentHandler.requireCommand({commandParts: parsedCommandParts})\n    const commandInstance = new CommandClass({\n      args: Object.assign({}, this.args, {processArgs}),\n      cli: this\n    })\n\n    await commandInstance.initialize()\n\n    return await commandInstance.execute()\n  }\n\n  /**\n   * Runs command groups.\n   * @returns {Promise<string[][]>} - Command groups with process args for each command.\n   */\n  async commandGroups() {\n    const processArgs = this.args.processArgs || []\n    const commands = await this.environmentHandler.findCommands()\n    const commandNames = new Set(commands.map((command) => command.name))\n    /**\n     * Groups.\n     * @type {string[][]} */\n    const groups = []\n    /**\n     * Current group.\n     * @type {string[]} */\n    let currentGroup = []\n\n    for (const processArg of processArgs) {\n      if (currentGroup.length == 0) {\n        if (processArg.startsWith(\"-\")) continue\n\n        currentGroup = [processArg]\n        continue\n      }\n\n      if (!processArg.startsWith(\"-\") && commandNames.has(processArg)) {\n        groups.push(currentGroup)\n        currentGroup = [processArg]\n      } else {\n        currentGroup.push(processArg)\n      }\n    }\n\n    if (currentGroup.length > 0) {\n      groups.push(currentGroup)\n    }\n\n    if (groups.length == 0) {\n      throw new Error(\"Missing command argument\")\n    }\n\n    return groups\n  }\n\n  /**\n   * Runs get configuration.\n   * @returns {import(\"../configuration.js\").default} configuration\n   */\n  getConfiguration() { return this.configuration }\n\n  /**\n   * Runs has current database connections.\n   * @returns {boolean} - Whether the current async context already has database connections.\n   */\n  hasCurrentDatabaseConnections() {\n    try {\n      return Object.keys(this.getConfiguration().getCurrentConnections()).length > 0\n    } catch (error) {\n      if (error instanceof Error && error.message.startsWith(\"No database configuration for environment:\")) return false\n\n      throw error\n    }\n  }\n\n  /**\n   * Runs get testing.\n   * @returns {boolean} - Whether testing.\n   */\n  getTesting() {\n    return this.args.testing || false\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/cli/index.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nconst COMMAND_VALUE_OPTIONS = new Set([\"--tenant\"])\n\nexport default class VelociousCli {\n  /**\n   * Runs constructor.\n   * @param {object} args - Options object.\n   * @param {import(\"../configuration.js\").default} [args.configuration] - Configuration instance.\n   * @param {string} [args.directory] - Directory path.\n   * @param {import(\"../environment-handlers/base.js\").default} [args.environmentHandler] - Environment handler.\n   * @param {Record<string, string | number | boolean | undefined>} [args.parsedProcessArgs] - Parsed process args.\n   * @param {string[]} [args.processArgs] - Process args.\n   * @param {boolean} [args.testing] - Whether testing.\n   */\n  constructor(args = {}) {\n    if (!args.configuration) throw new Error(\"configuration argument is required\")\n\n    this.args = args\n    this.configuration = args.configuration\n\n    this.environmentHandler = args.configuration.getEnvironmentHandler()\n    this.environmentHandler.setArgs(args)\n    this.environmentHandler.setConfiguration(args.configuration)\n  }\n\n  /**\n   * Runs execute.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - Resolves with the final command result.\n   */\n  async execute() {\n    const commandGroups = await this.commandGroups()\n    let result\n\n    for (const commandProcessArgs of commandGroups) {\n      const shouldCloseDatabaseConnections = !this.hasCurrentDatabaseConnections()\n\n      try {\n        result = await this.executeCommand(commandProcessArgs)\n      } finally {\n        if (shouldCloseDatabaseConnections) {\n          await this.getConfiguration().closeDatabaseConnections()\n        }\n      }\n    }\n\n    return result\n  }\n\n  /**\n   * Runs execute command.\n   * @param {string[]} processArgs - Process args for a single command.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - Resolves with the command result.\n   */\n  async executeCommand(processArgs) {\n    if (!processArgs[0]) {\n      throw new Error(\"Missing command argument\")\n    }\n\n    const commandParts = processArgs[0].split(\":\")\n    const parsedCommandParts = []\n\n    for (let commandPart of commandParts) {\n      if (commandPart == \"c\") commandPart = \"console\"\n      if (commandPart == \"d\") commandPart = \"destroy\"\n      if (commandPart == \"g\") commandPart = \"generate\"\n      if (commandPart == \"s\") commandPart = \"server\"\n\n      parsedCommandParts.push(commandPart)\n    }\n\n    const CommandClass = await this.environmentHandler.requireCommand({commandParts: parsedCommandParts})\n    const commandInstance = new CommandClass({\n      args: Object.assign({}, this.args, {processArgs}),\n      cli: this\n    })\n\n    await commandInstance.initialize()\n\n    return await commandInstance.execute()\n  }\n\n  /**\n   * Runs command groups.\n   * @returns {Promise<string[][]>} - Command groups with process args for each command.\n   */\n  async commandGroups() {\n    const processArgs = this.args.processArgs || []\n    const commands = await this.environmentHandler.findCommands()\n    const commandNames = new Set(commands.map((command) => command.name))\n    /**\n     * Groups.\n     * @type {string[][]} */\n    const groups = []\n    /**\n     * Current group.\n     * @type {string[]} */\n    let currentGroup = []\n    let expectsOptionValue = false\n\n    for (const processArg of processArgs) {\n      if (currentGroup.length == 0) {\n        if (processArg.startsWith(\"-\")) continue\n\n        currentGroup = [processArg]\n        continue\n      }\n\n      if (expectsOptionValue) {\n        currentGroup.push(processArg)\n        expectsOptionValue = false\n        continue\n      }\n\n      if (!processArg.startsWith(\"-\") && commandNames.has(processArg)) {\n        groups.push(currentGroup)\n        currentGroup = [processArg]\n      } else {\n        currentGroup.push(processArg)\n        expectsOptionValue = COMMAND_VALUE_OPTIONS.has(processArg)\n      }\n    }\n\n    if (currentGroup.length > 0) {\n      groups.push(currentGroup)\n    }\n\n    if (groups.length == 0) {\n      throw new Error(\"Missing command argument\")\n    }\n\n    return groups\n  }\n\n  /**\n   * Runs get configuration.\n   * @returns {import(\"../configuration.js\").default} configuration\n   */\n  getConfiguration() { return this.configuration }\n\n  /**\n   * Runs has current database connections.\n   * @returns {boolean} - Whether the current async context already has database connections.\n   */\n  hasCurrentDatabaseConnections() {\n    try {\n      return Object.keys(this.getConfiguration().getCurrentConnections()).length > 0\n    } catch (error) {\n      if (error instanceof Error && error.message.startsWith(\"No database configuration for environment:\")) return false\n\n      throw error\n    }\n  }\n\n  /**\n   * Runs get testing.\n   * @returns {boolean} - Whether testing.\n   */\n  getTesting() {\n    return this.args.testing || false\n  }\n}\n"]}