@decaf-ts/utils
Version:
module management utils for decaf-ts
147 lines • 18.1 kB
JavaScript
import { UserInput } from "./../input/input.js";
import { DefaultCommandOptions, DefaultCommandValues } from "./constants.js";
import { getDependencies, getPackageVersion } from "./../utils/fs.js";
import { printBanner } from "./../output/common.js";
import { Environment } from "./../utils/environment.js";
import { DefaultLoggingConfig, Logging, } from "@decaf-ts/logging";
/**
* @class Command
* @abstract
* @template I - The type of input options for the command.
* @template R - The return type of the command execution.
* @memberOf module:utils
* @description Abstract base class for command implementation.
* @summary Provides a structure for creating command-line interface commands with input handling, logging, and execution flow.
*
* @param {string} name - The name of the command.
* @param {CommandOptions<I>} [inputs] - The input options for the command.
* @param {string[]} [requirements] - The list of required dependencies for the command.
*/
export class Command {
constructor(name, inputs = {}, requirements = []) {
this.name = name;
this.inputs = inputs;
this.requirements = requirements;
if (!Command.log) {
Object.defineProperty(Command, "log", {
writable: false,
value: Logging.for(Command.name),
});
this.log = Command.log;
}
this.log = Command.log.for(this.name);
this.inputs = Object.assign({}, DefaultCommandOptions, inputs);
}
/**
* @protected
* @async
* @description Checks if all required dependencies are present.
* @summary Retrieves the list of dependencies and compares it against the required dependencies for the command.
* @returns {Promise<void>} A promise that resolves when the check is complete.
*
* @mermaid
* sequenceDiagram
* participant Command
* participant getDependencies
* participant Set
* Command->>getDependencies: Call
* getDependencies-->>Command: Return {prod, dev, peer}
* Command->>Set: Create Set from prod, dev, peer
* Set-->>Command: Return unique dependencies
* Command->>Command: Compare against requirements
* alt Missing dependencies
* Command->>Command: Add to missing list
* end
* Note over Command: If missing.length > 0, handle missing dependencies
*/
async checkRequirements() {
const { prod, dev, peer } = await getDependencies();
const missing = [];
const fullList = Array.from(new Set([...prod, ...dev, ...peer]).values()).map((d) => d.name);
for (const dep of this.requirements)
if (!fullList.includes(dep))
missing.push(dep);
if (!missing.length)
return;
}
/**
* @protected
* @description Provides help information for the command.
* @summary This method should be overridden in derived classes to provide specific help information.
* @param {ParseArgsResult} args - The parsed command-line arguments.
* @returns {void}
*/
// eslint-disable-next-line @typescript-eslint/no-unused-vars
help(args) {
return this.log.info(`This is help. I'm no use because I should have been overridden.`);
}
/**
* @async
* @description Executes the command.
* @summary This method handles the overall execution flow of the command, including parsing arguments,
* setting up logging, checking for version or help requests, and running the command.
* @returns {Promise<R | string | void>} A promise that resolves with the command's result.
*
* @mermaid
* sequenceDiagram
* participant Command
* participant UserInput
* participant Logging
* participant getPackageVersion
* participant printBanner
* Command->>UserInput: parseArgs(inputs)
* UserInput-->>Command: Return ParseArgsResult
* Command->>Command: Process options
* Command->>Logging: setConfig(options)
* alt version requested
* Command->>getPackageVersion: Call
* getPackageVersion-->>Command: Return version
* else help requested
* Command->>Command: help(args)
* else banner requested
* Command->>printBanner: Call
* end
* Command->>Command: run(args)
* alt error occurs
* Command->>Command: Log error
* end
* Command-->>Command: Return result
*/
async execute() {
const args = UserInput.parseArgs(this.inputs);
const env = Environment.accumulate(DefaultLoggingConfig)
.accumulate(DefaultCommandValues)
.accumulate(args.values);
const { timestamp, verbose, version, help, logLevel, logStyle, banner } = env;
this.log.setConfig({
...env,
timestamp: !!timestamp,
level: logLevel,
style: !!logStyle,
verbose: verbose || 0,
});
if (version) {
return getPackageVersion();
}
if (help) {
return this.help(args);
}
if (banner)
printBanner(this.log.for(printBanner, {
timestamp: false,
style: false,
context: false,
logLevel: false,
}));
let result;
try {
result = await this.run(env);
}
catch (e) {
this.log.error(`Error while running provided cli function: ${e}`);
throw e;
}
return result;
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"command.js","sourceRoot":"","sources":["../../../src/cli/command.ts"],"names":[],"mappings":"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","sourcesContent":["import { ParseArgsResult } from \"../input/types\";\nimport { CommandOptions } from \"./types\";\nimport { UserInput } from \"../input/input\";\nimport { DefaultCommandOptions, DefaultCommandValues } from \"./constants\";\nimport { getDependencies, getPackageVersion } from \"../utils/fs\";\nimport { printBanner } from \"../output/common\";\nimport { Environment } from \"../utils/environment\";\nimport {\n  DefaultLoggingConfig,\n  Logger,\n  Logging,\n  LoggingConfig,\n  LogLevel,\n} from \"@decaf-ts/logging\";\n\n/**\n * @class Command\n * @abstract\n * @template I - The type of input options for the command.\n * @template R - The return type of the command execution.\n * @memberOf module:utils\n * @description Abstract base class for command implementation.\n * @summary Provides a structure for creating command-line interface commands with input handling, logging, and execution flow.\n *\n * @param {string} name - The name of the command.\n * @param {CommandOptions<I>} [inputs] - The input options for the command.\n * @param {string[]} [requirements] - The list of required dependencies for the command.\n */\nexport abstract class Command<I, R> {\n  /**\n   * @static\n   * @description Static logger for the Command class.\n   * @type {Logger}\n   */\n  static log: Logger;\n\n  /**\n   * @protected\n   * @description Instance logger for the command.\n   * @type {Logger}\n   */\n  protected log: Logger;\n\n  protected constructor(\n    protected name: string,\n    protected inputs: CommandOptions<I> = {} as unknown as CommandOptions<I>,\n    protected requirements: string[] = []\n  ) {\n    if (!Command.log) {\n      Object.defineProperty(Command, \"log\", {\n        writable: false,\n        value: Logging.for(Command.name),\n      });\n      this.log = Command.log;\n    }\n    this.log = Command.log.for(this.name);\n    this.inputs = Object.assign(\n      {},\n      DefaultCommandOptions,\n      inputs\n    ) as CommandOptions<I>;\n  }\n\n  /**\n   * @protected\n   * @async\n   * @description Checks if all required dependencies are present.\n   * @summary Retrieves the list of dependencies and compares it against the required dependencies for the command.\n   * @returns {Promise<void>} A promise that resolves when the check is complete.\n   *\n   * @mermaid\n   * sequenceDiagram\n   *   participant Command\n   *   participant getDependencies\n   *   participant Set\n   *   Command->>getDependencies: Call\n   *   getDependencies-->>Command: Return {prod, dev, peer}\n   *   Command->>Set: Create Set from prod, dev, peer\n   *   Set-->>Command: Return unique dependencies\n   *   Command->>Command: Compare against requirements\n   *   alt Missing dependencies\n   *     Command->>Command: Add to missing list\n   *   end\n   *   Note over Command: If missing.length > 0, handle missing dependencies\n   */\n  protected async checkRequirements(): Promise<void> {\n    const { prod, dev, peer } = await getDependencies();\n    const missing = [];\n    const fullList = Array.from(\n      new Set([...prod, ...dev, ...peer]).values()\n    ).map((d) => d.name);\n    for (const dep of this.requirements)\n      if (!fullList.includes(dep)) missing.push(dep);\n\n    if (!missing.length) return;\n  }\n\n  /**\n   * @protected\n   * @description Provides help information for the command.\n   * @summary This method should be overridden in derived classes to provide specific help information.\n   * @param {ParseArgsResult} args - The parsed command-line arguments.\n   * @returns {void}\n   */\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  protected help(args: ParseArgsResult): void {\n    return this.log.info(\n      `This is help. I'm no use because I should have been overridden.`\n    );\n  }\n\n  /**\n   * @protected\n   * @abstract\n   * @description Runs the command with the provided arguments.\n   * @summary This method should be implemented in derived classes to define the command's behavior.\n   * @param {ParseArgsResult} answers - The parsed command-line arguments.\n   * @returns {Promise<R | string | void>} A promise that resolves with the command's result.\n   */\n  protected abstract run<R>(\n    answers: LoggingConfig &\n      typeof DefaultCommandValues & { [k in keyof I]: unknown }\n  ): Promise<R | string | void>;\n\n  /**\n   * @async\n   * @description Executes the command.\n   * @summary This method handles the overall execution flow of the command, including parsing arguments,\n   * setting up logging, checking for version or help requests, and running the command.\n   * @returns {Promise<R | string | void>} A promise that resolves with the command's result.\n   *\n   * @mermaid\n   * sequenceDiagram\n   *   participant Command\n   *   participant UserInput\n   *   participant Logging\n   *   participant getPackageVersion\n   *   participant printBanner\n   *   Command->>UserInput: parseArgs(inputs)\n   *   UserInput-->>Command: Return ParseArgsResult\n   *   Command->>Command: Process options\n   *   Command->>Logging: setConfig(options)\n   *   alt version requested\n   *     Command->>getPackageVersion: Call\n   *     getPackageVersion-->>Command: Return version\n   *   else help requested\n   *     Command->>Command: help(args)\n   *   else banner requested\n   *     Command->>printBanner: Call\n   *   end\n   *   Command->>Command: run(args)\n   *   alt error occurs\n   *     Command->>Command: Log error\n   *   end\n   *   Command-->>Command: Return result\n   */\n  async execute(): Promise<R | string | void> {\n    const args: ParseArgsResult = UserInput.parseArgs(this.inputs);\n    const env = Environment.accumulate(DefaultLoggingConfig)\n      .accumulate(DefaultCommandValues)\n      .accumulate(args.values);\n    const { timestamp, verbose, version, help, logLevel, logStyle, banner } =\n      env;\n\n    this.log.setConfig({\n      ...env,\n      timestamp: !!timestamp,\n      level: logLevel as LogLevel,\n      style: !!logStyle,\n      verbose: (verbose as number) || 0,\n    });\n\n    if (version) {\n      return getPackageVersion();\n    }\n\n    if (help) {\n      return this.help(args);\n    }\n\n    if (banner)\n      printBanner(\n        this.log.for(printBanner, {\n          timestamp: false,\n          style: false,\n          context: false,\n          logLevel: false,\n        })\n      );\n\n    let result;\n    try {\n      result = await this.run(env);\n    } catch (e: unknown) {\n      this.log.error(`Error while running provided cli function: ${e}`);\n      throw e;\n    }\n\n    return result as R;\n  }\n}\n"]}