velocious 1.0.431 → 1.0.433

package/build/src/cli/index.js

@@ -1,152 +1,138 @@
 // @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()
+    /**
+     * 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;
     }
-
-    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")
+    /**
+     * 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();
     }
-
-    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)
+    /**
+     * 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;
     }
-
-    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 = []
+     * Runs get configuration.
+     * @returns {import("../configuration.js").default} configuration
+     */
+    getConfiguration() { return this.configuration; }
     /**
-     * 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")
+     * 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;
+        }
     }
-
-    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;
     }
-  }
-
-  /**
-   * Runs get testing.
-   * @returns {boolean} - Whether testing.
-   */
-  getTesting() {
-    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<?>} - 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<?>} - 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"]}