velocious 1.0.430 → 1.0.432

package/build/cli/commands/db/tenants/create.js

@@ -0,0 +1,33 @@
+// @ts-check
+
+import BaseCommand from "../../../base-command.js"
+import TenantDatabaseCommandHelper from "../../../tenant-database-command-helper.js"
+
+export default class DbTenantsCreate extends BaseCommand {
+  /**
+   * Runs execute.
+   * @returns {Promise<{identifier: string, tenantCount: number} | void>} - Result in test mode.
+   */
+  async execute() {
+    const helper = new TenantDatabaseCommandHelper({
+      command: this,
+      identifier: this.processArgs?.[1]
+    })
+    const provider = helper.provider
+
+    if (typeof provider.createDatabase !== "function") {
+      throw new Error(`Tenant database provider for ${helper.identifier} must define createDatabase to use db:tenants:create`)
+    }
+
+    const tenantCount = await helper.eachTenant(async ({databaseConfiguration, tenant}) => {
+      await provider.createDatabase?.({
+        configuration: this.getConfiguration(),
+        databaseConfiguration,
+        identifier: helper.identifier,
+        tenant
+      })
+    })
+
+    if (this.args.testing) return {identifier: helper.identifier, tenantCount}
+  }
+}

package/build/cli/commands/db/tenants/migrate.js

@@ -0,0 +1,49 @@
+// @ts-check
+
+import {digg} from "diggerize"
+import BaseCommand from "../../../base-command.js"
+import Migrator from "../../../../database/migrator.js"
+import TenantDatabaseCommandHelper from "../../../tenant-database-command-helper.js"
+
+export default class DbTenantsMigrate extends BaseCommand {
+  /**
+   * Runs execute.
+   * @returns {Promise<{identifier: string, migrationCount: number, tenantCount: number} | void>} - Result in test mode.
+   */
+  async execute() {
+    const helper = new TenantDatabaseCommandHelper({
+      command: this,
+      identifier: this.processArgs?.[1]
+    })
+    const migrations = await this.getEnvironmentHandler().findMigrations()
+    const tenantCount = await helper.eachTenant(async ({databaseConfiguration, tenant}) => {
+      const migrator = new Migrator({
+        configuration: this.getConfiguration(),
+        databaseIdentifiers: [helper.identifier]
+      })
+
+      await this.getConfiguration().ensureConnections({name: `DB tenants migrate: ${helper.identifier}`}, async () => {
+        await migrator.prepare()
+        const migrationsApplied = await migrator.migrateFiles(migrations, digg(this.getEnvironmentHandler(), "requireMigration"))
+
+        if (typeof helper.provider.afterMigrateTenant === "function") {
+          await helper.provider.afterMigrateTenant({
+            configuration: this.getConfiguration(),
+            databaseConfiguration,
+            identifier: helper.identifier,
+            migrationsApplied,
+            tenant
+          })
+        }
+      })
+    })
+
+    if (this.args.testing) {
+      return {
+        identifier: helper.identifier,
+        migrationCount: migrations.length,
+        tenantCount
+      }
+    }
+  }
+}

package/build/cli/commands/destroy/migration.js

@@ -0,0 +1,7 @@
+import BaseCommand from "../../base-command.js"
+
+export default class DbDestroyMigration extends BaseCommand {
+  async execute() {
+    return await this.getConfiguration().getEnvironmentHandler().cliCommandsMigrationDestroy(this)
+  }
+}

package/build/cli/commands/generate/base-models.js

@@ -0,0 +1,7 @@
+import BaseCommand from "../../base-command.js"
+
+export default class DbGenerateBaseModels extends BaseCommand {
+  async execute() {
+    return await this.getConfiguration().getEnvironmentHandler().cliCommandsGenerateBaseModels(this)
+  }
+}

package/build/cli/commands/generate/frontend-models.js

@@ -0,0 +1,12 @@
+import BaseCommand from "../../base-command.js"
+
+/** Frontend model generator command wrapper. */
+export default class DbGenerateFrontendModels extends BaseCommand {
+  /**
+   * Runs execute.
+   * @returns {Promise<?>} - Command execution result.
+   */
+  async execute() {
+    return await this.getConfiguration().getEnvironmentHandler().cliCommandsGenerateFrontendModels(this)
+  }
+}

package/build/cli/commands/generate/migration.js

@@ -0,0 +1,7 @@
+import BaseCommand from "../../base-command.js"
+
+export default class DbGenerateMigration extends BaseCommand {
+  async execute() {
+    return await this.getConfiguration().getEnvironmentHandler().cliCommandsMigrationGenerate(this)
+  }
+}

package/build/cli/commands/generate/model.js

@@ -0,0 +1,7 @@
+import BaseCommand from "../../base-command.js"
+
+export default class DbGenerateModel extends BaseCommand {
+  async execute() {
+    return await this.getConfiguration().getEnvironmentHandler().cliCommandsGenerateModel(this)
+  }
+}

package/build/cli/commands/init.js

@@ -0,0 +1,11 @@
+import BaseCommand from "../base-command.js"
+
+export default class VelociousCliCommandsInit extends BaseCommand {
+  async execute() {
+    return await this.getConfiguration().getEnvironmentHandler().cliCommandsInit(this)
+  }
+}
+
+const dontLoadConfiguration = true
+
+export {dontLoadConfiguration}

package/build/cli/commands/routes.js

@@ -0,0 +1,7 @@
+import BaseCommand from "../base-command.js"
+
+export default class VelociousCliCommandsRoutes extends BaseCommand{
+  async execute() {
+    return await this.getConfiguration().getEnvironmentHandler().cliCommandsRoutes(this)
+  }
+}

package/build/cli/commands/run-script.js

@@ -0,0 +1,12 @@
+import BaseCommand from "../base-command.js"
+
+/** CLI command for loading and running a user-provided script file. */
+export default class RunScriptCommand extends BaseCommand {
+  /**
+   * Runs execute.
+   * @returns {Promise<?>} - Resolves with the command result.
+   */
+  async execute() {
+    return await this.getConfiguration().getEnvironmentHandler().cliCommandsRunScript(this)
+  }
+}

package/build/cli/commands/runner.js

@@ -0,0 +1,12 @@
+import BaseCommand from "../base-command.js"
+
+/** CLI command for evaluating inline JavaScript in app context. */
+export default class RunnerCommand extends BaseCommand {
+  /**
+   * Runs execute.
+   * @returns {Promise<?>} - Resolves with the command result.
+   */
+  async execute() {
+    return await this.getConfiguration().getEnvironmentHandler().cliCommandsRunner(this)
+  }
+}

package/build/cli/commands/server.js

@@ -0,0 +1,7 @@
+import BaseCommand from "../base-command.js"
+
+export default class VelociousCliCommandsServer extends BaseCommand{
+  async execute() {
+    return await this.getConfiguration().getEnvironmentHandler().cliCommandsServer(this)
+  }
+}

package/build/cli/commands/test.js

@@ -0,0 +1,9 @@
+import BaseCommand from "../base-command.js"
+
+export default class VelociousCliCommandsTest extends BaseCommand {
+  async execute() {
+    this.getConfiguration().setEnvironment("test")
+
+    return await this.getConfiguration().getEnvironmentHandler().cliCommandsTest(this)
+  }
+}

package/build/cli/index.js

@@ -0,0 +1,152 @@
+// @ts-check
+
+export default class VelociousCli {
+  /**
+   * Runs constructor.
+   * @param {object} args - Options object.
+   * @param {import("../configuration.js").default} [args.configuration] - Configuration instance.
+   * @param {string} [args.directory] - Directory path.
+   * @param {import("../environment-handlers/base.js").default} [args.environmentHandler] - Environment handler.
+   * @param {Record<string, string | number | boolean | undefined>} [args.parsedProcessArgs] - Parsed process args.
+   * @param {string[]} [args.processArgs] - Process args.
+   * @param {boolean} [args.testing] - Whether testing.
+   */
+  constructor(args = {}) {
+    if (!args.configuration) throw new Error("configuration argument is required")
+
+    this.args = args
+    this.configuration = args.configuration
+
+    this.environmentHandler = args.configuration.getEnvironmentHandler()
+    this.environmentHandler.setArgs(args)
+    this.environmentHandler.setConfiguration(args.configuration)
+  }
+
+  /**
+   * Runs execute.
+   * @returns {Promise<?>} - Resolves with the final command result.
+   */
+  async execute() {
+    const commandGroups = await this.commandGroups()
+    let result
+
+    for (const commandProcessArgs of commandGroups) {
+      const shouldCloseDatabaseConnections = !this.hasCurrentDatabaseConnections()
+
+      try {
+        result = await this.executeCommand(commandProcessArgs)
+      } finally {
+        if (shouldCloseDatabaseConnections) {
+          await this.getConfiguration().closeDatabaseConnections()
+        }
+      }
+    }
+
+    return result
+  }
+
+  /**
+   * Runs execute command.
+   * @param {string[]} processArgs - Process args for a single command.
+   * @returns {Promise<?>} - Resolves with the command result.
+   */
+  async executeCommand(processArgs) {
+    if (!processArgs[0]) {
+      throw new Error("Missing command argument")
+    }
+
+    const commandParts = processArgs[0].split(":")
+    const parsedCommandParts = []
+
+    for (let commandPart of commandParts) {
+      if (commandPart == "c") commandPart = "console"
+      if (commandPart == "d") commandPart = "destroy"
+      if (commandPart == "g") commandPart = "generate"
+      if (commandPart == "s") commandPart = "server"
+
+      parsedCommandParts.push(commandPart)
+    }
+
+    const CommandClass = await this.environmentHandler.requireCommand({commandParts: parsedCommandParts})
+    const commandInstance = new CommandClass({
+      args: Object.assign({}, this.args, {processArgs}),
+      cli: this
+    })
+
+    await commandInstance.initialize()
+
+    return await commandInstance.execute()
+  }
+
+  /**
+   * Runs command groups.
+   * @returns {Promise<string[][]>} - Command groups with process args for each command.
+   */
+  async commandGroups() {
+    const processArgs = this.args.processArgs || []
+    const commands = await this.environmentHandler.findCommands()
+    const commandNames = new Set(commands.map((command) => command.name))
+    /**
+     * Groups.
+      @type {string[][]} */
+    const groups = []
+    /**
+     * Current group.
+      @type {string[]} */
+    let currentGroup = []
+
+    for (const processArg of processArgs) {
+      if (currentGroup.length == 0) {
+        if (processArg.startsWith("-")) continue
+
+        currentGroup = [processArg]
+        continue
+      }
+
+      if (!processArg.startsWith("-") && commandNames.has(processArg)) {
+        groups.push(currentGroup)
+        currentGroup = [processArg]
+      } else {
+        currentGroup.push(processArg)
+      }
+    }
+
+    if (currentGroup.length > 0) {
+      groups.push(currentGroup)
+    }
+
+    if (groups.length == 0) {
+      throw new Error("Missing command argument")
+    }
+
+    return groups
+  }
+
+  /**
+   * Runs get configuration.
+   * @returns {import("../configuration.js").default} configuration
+   */
+  getConfiguration() { return this.configuration }
+
+  /**
+   * Runs has current database connections.
+   * @returns {boolean} - Whether the current async context already has database connections.
+   */
+  hasCurrentDatabaseConnections() {
+    try {
+      return Object.keys(this.getConfiguration().getCurrentConnections()).length > 0
+    } catch (error) {
+      if (error instanceof Error && error.message.startsWith("No database configuration for environment:")) return false
+
+      throw error
+    }
+  }
+
+  /**
+   * Runs get testing.
+   * @returns {boolean} - Whether testing.
+   */
+  getTesting() {
+    return this.args.testing || false
+  }
+}

package/build/cli/tenant-database-command-helper.js

@@ -0,0 +1,198 @@
+// @ts-check
+
+export default class TenantDatabaseCommandHelper {
+  /**
+   * Runs constructor.
+   * @param {object} args - Options object.
+   * @param {import("./base-command.js").default} args.command - CLI command instance.
+   * @param {string | undefined} args.identifier - Tenant database identifier.
+   */
+  constructor({command, identifier}) {
+    if (!identifier) throw new Error("Missing tenant database identifier argument")
+
+    this.command = command
+    this.configuration = command.getConfiguration()
+    this.identifier = identifier
+    this.provider = this.configuration.getTenantDatabaseProvider(identifier)
+  }
+
+  /**
+   * Runs validate tenant database identifier.
+    @returns {void} */
+  validateTenantDatabaseIdentifier() {
+    const databaseConfiguration = this.configuration.getDatabaseConfiguration()[this.identifier]
+
+    if (!databaseConfiguration) {
+      throw new Error(`No such database identifier configured: ${this.identifier}`)
+    }
+
+    if (!databaseConfiguration.tenantOnly) {
+      throw new Error(`Database identifier ${this.identifier} is not configured with tenantOnly: true`)
+    }
+
+    if (this.configuration.getDisabledDatabaseIdentifiers().has(this.identifier)) {
+      throw new Error(`Tenant database identifier ${this.identifier} is disabled by VELOCIOUS_DISABLED_DATABASE_IDENTIFIERS`)
+    }
+
+    if (typeof this.provider.listTenants !== "function") {
+      throw new Error(`Tenant database provider for ${this.identifier} must define listTenants`)
+    }
+  }
+
+  /**
+   * Runs initialize runtime.
+   * @returns {Promise<void>} - Resolves when app runtime is initialized.
+   */
+  async initializeRuntime() {
+    await this.configuration.initialize({type: "db-tenants"})
+  }
+
+  /**
+   * Runs list tenants.
+   * @returns {Promise<Array<?>>} - Tenants.
+   */
+  async listTenants() {
+    this.validateTenantDatabaseIdentifier()
+    await this.initializeRuntime()
+
+    const tenants = await this.configuration.ensureConnections({name: `Tenant database list: ${this.identifier}`}, async () => {
+      return await this.provider.listTenants({
+        configuration: this.configuration,
+        identifier: this.identifier
+      })
+    })
+
+    if (!Array.isArray(tenants)) {
+      throw new Error(`Tenant database provider for ${this.identifier} must return an array from listTenants`)
+    }
+
+    return tenants
+  }
+
+  /**
+   * Runs each tenant.
+   * @param {function({databaseConfiguration: import("../configuration-types.js").DatabaseConfigurationType, tenant: ?}) : Promise<void>} callback - Callback.
+   * @returns {Promise<number>} - Number of tenants processed.
+   */
+  async eachTenant(callback) {
+    const tenants = await this.listTenants()
+    const parallelCount = this.parallelCount()
+
+    if (parallelCount <= 1) {
+      for (const tenant of tenants) {
+        await this.runTenantCallback({callback, tenant})
+      }
+
+      return tenants.length
+    }
+
+    /**
+     * Failures.
+      @type {Array<{error: Error, tenant: ?}>} */
+    const failures = []
+    const workers = []
+    let tenantIndex = 0
+    const workerCount = Math.min(parallelCount, tenants.length)
+
+    for (let workerIndex = 0; workerIndex < workerCount; workerIndex++) {
+      workers.push((async () => {
+        while (tenantIndex < tenants.length) {
+          const tenant = tenants[tenantIndex]
+
+          tenantIndex++
+
+          try {
+            await this.runTenantCallback({callback, tenant})
+          } catch (error) {
+            failures.push({
+              error: error instanceof Error ? error : new Error(String(error)),
+              tenant
+            })
+          }
+        }
+      })())
+    }
+
+    await Promise.all(workers)
+
+    if (failures.length > 0) {
+      const failedTenantLabels = failures.map((failure) => this.tenantLabel(failure.tenant)).join(", ")
+
+      throw new AggregateError(
+        failures.map((failure) => failure.error),
+        `Failed tenant database command for tenant(s): ${failedTenantLabels}`
+      )
+    }
+
+    return tenants.length
+  }
+
+  /**
+   * Runs parallel count.
+   * @returns {number} - Number of tenants to process concurrently.
+   */
+  parallelCount() {
+    const parsedProcessArgs = this.command.args?.parsedProcessArgs || {}
+    let parallelArg = parsedProcessArgs.parallel
+
+    if (parallelArg === undefined) {
+      const parallelArgIndex = this.command.processArgs?.indexOf("--parallel") ?? -1
+
+      if (parallelArgIndex >= 0) {
+        const nextArg = this.command.processArgs?.[parallelArgIndex + 1]
+
+        parallelArg = nextArg && !nextArg.startsWith("-") ? nextArg : true
+      }
+    }
+
+    if (parallelArg === undefined || parallelArg === false) return 1
+    if (parallelArg === true) return 20
+
+    const parallelCount = Number(parallelArg)
+
+    if (!Number.isInteger(parallelCount) || parallelCount < 1) {
+      throw new Error(`--parallel must be a positive integer when a value is provided: ${parallelArg}`)
+    }
+
+    return parallelCount
+  }
+
+  /**
+   * Runs run tenant callback.
+   * @param {object} args - Tenant callback args.
+   * @param {function({databaseConfiguration: import("../configuration-types.js").DatabaseConfigurationType, tenant: ?}) : Promise<void>} args.callback - Callback.
+   * @param {?} args.tenant - Tenant.
+   * @returns {Promise<void>}
+   */
+  async runTenantCallback({callback, tenant}) {
+    await this.configuration.runWithTenant(tenant, async () => {
+      if (!this.configuration.isDatabaseIdentifierActive(this.identifier)) {
+        throw new Error(`Tenant database identifier ${this.identifier} is inactive for tenant: ${this.tenantLabel(tenant)}`)
+      }
+
+      await callback({
+        databaseConfiguration: this.configuration.resolveDatabaseConfiguration(this.identifier),
+        tenant
+      })
+    })
+  }
+
+  /**
+   * Runs tenant label.
+   * @param {?} tenant - Tenant.
+   * @returns {string} - Human readable tenant label.
+   */
+  tenantLabel(tenant) {
+    if (tenant && typeof tenant === "object") {
+      const tenantObject = /**
+                            * Narrows the runtime value to the documented type.
+                             @type {{id?: ?, name?: ?, slug?: ?}} */ (tenant)
+
+      if (tenantObject.slug) return String(tenantObject.slug)
+      if (tenantObject.name) return String(tenantObject.name)
+      if (tenantObject.id) return String(tenantObject.id)
+    }
+
+    return JSON.stringify(tenant)
+  }
+}

package/build/cli/use-browser-cli.js

@@ -0,0 +1,30 @@
+import React from "react"
+
+import BrowserCli from "./browser-cli.js"
+import restArgsError from "../utils/rest-args-error.js"
+
+/**
+ * Shared.
+  @type {{browserCli?: BrowserCli}} */
+const shared = {}
+
+/**
+ * Runs velocious use browser cli.
+ * @param {object} args - Options object.
+ * @param {import("../configuration.js").default} args.configuration - Configuration instance.
+ * @returns {BrowserCli} browserCli
+ */
+export default function velociousUseBrowserCli({configuration, ...restArgs}) {
+  const browserCli = React.useMemo(() => {
+    if (!shared.browserCli) {
+      shared.browserCli = new BrowserCli({configuration})
+      shared.browserCli.enable()
+    }
+
+    return shared.browserCli
+  }, [configuration])
+
+  restArgsError(restArgs)
+
+  return browserCli
+}

package/build/configuration-resolver.js

@@ -0,0 +1,65 @@
+// @ts-check
+
+import Configuration, {CurrentConfigurationNotSetError} from "./configuration.js"
+import envSense from "env-sense/build/use-env-sense.js"
+import fileExists from "./utils/file-exists.js"
+import toImportSpecifier from "./utils/to-import-specifier.js"
+
+/**
+ * Runs configuration resolver.
+ * @param {import("./configuration-types.js").ConfigurationArgsType} [args] - Options object.
+ * @returns {Promise<Configuration>} - Resolves with value.
+ */
+export default async function configurationResolver(args) {
+  let configuration
+
+  try {
+    configuration = Configuration.current()
+  } catch (error) {
+    if (error instanceof CurrentConfigurationNotSetError) {
+      // Ignore
+    } else {
+      throw error
+    }
+  }
+
+  if (configuration) {
+    return Configuration.current()
+  }
+
+  const directory = args?.directory || process.cwd()
+  let configurationPrePath = `${directory}/src/config/configuration`
+  const configurationPathForNode = `${configurationPrePath}.node.js`
+  const configurationPathDefault = `${configurationPrePath}.js`
+  const {isServer} = envSense()
+  let configurationPath
+
+  if (isServer && await fileExists(configurationPathForNode)) {
+    configurationPath = configurationPathForNode
+  } else {
+    configurationPath = configurationPathDefault
+  }
+
+  try {
+    const configurationImport = await import(toImportSpecifier(configurationPath))
+
+    configuration = configurationImport.default
+  } catch (error) {
+    console.log(`Couldn't load configuration from ${configurationPath} because of: ${error instanceof Error ? error.message : error}`)
+
+    if (error instanceof Error) {
+      // This might happen during an "init" CLI command where we copy a sample configuration file.
+      if (!error.message.match(/^Cannot find module '(.+)\/configuration\.js'/)) {
+        throw error
+      }
+    }
+
+    if (!args) {
+      throw new Error("Can't spawn a new configuration because no configuration-arguments was given", {cause: error})
+    }
+
+    configuration = new Configuration(args)
+  }
+
+  return configuration
+}