task-script-support-cli 0.1.1 → 0.2.4

package/src/services/prompt-service.ts

@@ -0,0 +1,71 @@
+import { autoInjectable } from "tsyringe";
+import { UtilService } from "./util-service";
+
+import sortableCheckbox from "inquirer-sortable-checkbox";
+
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const { search, input } = require("@inquirer/prompts");
+
+@autoInjectable()
+export class PromptService {
+  constructor(private utilService: UtilService) {}
+
+  /**
+   * Select an option from a list of choices. Allows search filtering.
+   * See: https://github.com/SBoudrias/Inquirer.js/tree/main/packages/search
+   *
+   * @param message the message to prompt (question to ask).
+   * @param options the selectable choices to search / choose from.
+   * @returns the selected choice value
+   */
+  async select(message: string, options: string[]) {
+    // wait for logging to catch up before prompting
+    await this.utilService.sleep(800);
+
+    const choices = options.map((opt) => ({ value: opt }));
+
+    const answer = await search({
+      message,
+      source: async (input: string | void) => {
+        if (!input) {
+          return choices;
+        }
+        return choices.filter((c) =>
+          c.value.toLowerCase().includes(input.toLowerCase()),
+        );
+      },
+    });
+
+    return answer;
+  }
+
+  /**
+   * Get a simple input string from the user.
+   *
+   * @param message the message to prompt the user with
+   * @param required whether or not to throw an error on empty input.
+   * @returns the read input string or undefined if not required
+   */
+  async getInput(message: string, required: boolean = true) {
+    await this.utilService.sleep(800);
+    return await input({ message, required });
+  }
+
+  /**
+   * Prompt with multi-select options returning the array of selections.
+   *
+   * @param message the message string to prompt with.
+   * @param options the options to choose from.
+   * @returns the selected optoins array
+   */
+  async pickMultiple<T>(
+    message: string,
+    options: { name: string; value: T }[],
+  ): Promise<T[]> {
+    await this.utilService.sleep(800);
+    return await sortableCheckbox({
+      message,
+      choices: options,
+    });
+  }
+}

package/src/services/spawn-service.ts

@@ -4,6 +4,15 @@ import { singleton } from "tsyringe";
 
 @singleton()
 export class SpawnService {
+  execSyncFromDir(command: string, dir: string) {
+    try {
+      return childProcess.execSync(command, { cwd: dir }).toString();
+    } catch (error) {
+      console.error(`Error executing command: ${command}`);
+      throw error;
+    }
+  }
+
   execSync(command: string) {
     try {
       return childProcess.execSync(command).toString();
@@ -15,7 +24,12 @@ export class SpawnService {
 
   exec(command: string) {
     try {
-      return childProcess.exec(command).toString();
+      return new Promise((res, rej) => {
+        return childProcess.exec(command, (err, stdout, stderr) => {
+          if (err) return rej(err);
+          return res({ stdout, stderr });
+        });
+      });
     } catch (error) {
       console.error(`Error executing command: ${command}`, error);
       throw error;

package/src/services/util-service.ts

@@ -84,4 +84,9 @@ export class UtilService {
 
     return null;
   }
+
+  sleep = (ms: number) => UtilService.sleep(ms);
+  static async sleep(ms: number) {
+    await new Promise((res) => setTimeout(res, ms));
+  }
 }

package/src/tasks/check-env.ts

@@ -2,7 +2,7 @@ import chalk from "chalk";
 import { AppTask } from "../wrappers/app-task";
 import { autoInjectable } from "tsyringe";
 import { EnvironmentConfigKeys } from "../types/state";
-import FileService from "../services/file-service";
+import { FileService } from "../services/file-service";
 import path from "path";
 
 /**
@@ -20,6 +20,7 @@ export default class CheckEnvironment extends AppTask {
     EnvironmentConfigKeys.PINO_LOG_DIR_PATH,
     EnvironmentConfigKeys.PINO_LOG_FILENAME,
     EnvironmentConfigKeys.PINO_LOG_LEVEL,
+    EnvironmentConfigKeys.TSSC_SILENCE_BANNER,
   ];
 
   constructor(private fileService: FileService) {
@@ -48,7 +49,8 @@ export default class CheckEnvironment extends AppTask {
 
   /**
    * Check for the folders we need to generate files in. Add errors
-   * when no target directories can be found.
+   * when no target directories can be found. Saves project data to
+   * state so we don't have to refetch it later.
    *
    * @param projectDir the target project root directory path
    * @param errors string array error messages are added to
@@ -65,6 +67,12 @@ export default class CheckEnvironment extends AppTask {
         errors.push(`Unable to find any ${k} in project`);
       }
     });
+    this.setData({
+      project: {
+        rootDir: projectDir,
+        ...directories,
+      },
+    });
   }
 
   /**

package/src/tasks/configure.ts

@@ -0,0 +1,105 @@
+import chalk from "chalk";
+import { AppTask } from "../wrappers/app-task";
+import { autoInjectable } from "tsyringe";
+import { GenTargetType } from "../types/state";
+import { ProjectConfig, ProjectData } from "../types/project";
+import { PromptService } from "../services/prompt-service";
+import { CacheService } from "../services/cache-service";
+import { UtilService } from "../services/util-service";
+
+/**
+ * Configures the Project Settings Cache in a Proactive way.
+ * Prompts for each resource type destination if not
+ * yet configured and multiple directories are found.
+ */
+@autoInjectable()
+export default class ConfigureCache extends AppTask {
+  loggerName = "Configure";
+
+  constructor(
+    private promptService: PromptService,
+    private cacheService: CacheService,
+    private utilService: UtilService,
+  ) {
+    super();
+  }
+
+  /**
+   * Configure each resource type's output destination directory. Allows
+   * the user to reset these values if their project has changed since
+   * last cached.
+   */
+  async run() {
+    this.logger.info(chalk.blueBright("Checking Configuration"));
+    const project: ProjectConfig & ProjectData = this.state.data.project!;
+
+    project.commandDestination = await this.getDestination(
+      GenTargetType.Command,
+    );
+    project.serviceDestination = await this.getDestination(
+      GenTargetType.Service,
+    );
+    project.taskDestination = await this.getDestination(GenTargetType.Task);
+
+    this.logger.debug(chalk.blackBright(`Saving configuration`));
+    await this.cacheService.writeProject(project);
+    this.setData({ project });
+  }
+
+  /**
+   * Prints the target destination path string
+   *
+   * @param dest the destination path to log
+   * @returns
+   */
+  logDestination = (dest: string = "") =>
+    this.logger.debug(`Destination: ${chalk.magentaBright(dest)}`);
+
+  /**
+   * Gets the destination path for generating resources by resource type.
+   * If only one resource destination folder was found it is returned
+   * otherwise the user is prompted to select one from the found folders.
+   *
+   * @param keyType the type of destination to resolve
+   * @returns the path of the resolved destination
+   */
+  async getDestination(keyType: "command" | "task" | "service") {
+    const foldersKey: keyof typeof this.state.data.project =
+      `${keyType}Folders` as keyof typeof this.state.data.project;
+
+    const nonTestFolders: string[] = (
+      this.state.data.project![foldersKey] as string[]
+    ).filter((folder: string) => !(folder || "").includes("/tests/"));
+
+    // if we only have one folder found, use this as the destination
+    const titleizedKey = chalk.blueBright(this.utilService.titleize(keyType));
+    if (nonTestFolders.length === 1) {
+      this.logger.debug(`Configuring single found ${titleizedKey} folder`);
+      return nonTestFolders[0] || "";
+    }
+
+    // otherwise prompt to pick one
+    await this.logger.flush();
+    const userSelection: string = await this.promptService.select(
+      `Multiple folders found. Select correct ${titleizedKey} folder`,
+      nonTestFolders,
+    );
+    return userSelection;
+  }
+
+  //@override
+  async preRun() {
+    this.verifyState();
+  }
+
+  /**
+   * Check we have all the required state set
+   */
+  verifyState() {
+    if (!this.state.data.project || !this.state.data.project.rootDir) {
+      throw new Error(
+        `Missing project rootDir! ${this.constructor.name} requires the CheckEnvironment task to be ran first.`,
+      );
+    }
+  }
+}

package/src/tasks/create-new-project.ts

@@ -0,0 +1,66 @@
+import { SpawnService } from "../services/spawn-service";
+import { FileService } from "../services/file-service";
+import { PromptService } from "../services/prompt-service";
+import { CLIOptions } from "../types/process";
+import { AppTask } from "../wrappers/app-task";
+import { autoInjectable } from "tsyringe";
+
+/**
+ * Creates a New Task Script Support Project
+ */
+@autoInjectable()
+export default class CreateNewProject extends AppTask {
+  loggerName = "Create New Project";
+
+  constructor(
+    private fileService: FileService,
+    private spawnService: SpawnService,
+    private promptService: PromptService,
+  ) {
+    super();
+  }
+
+  /**
+   * Generates a new project. Updates state with outputDestination of the
+   * newly generated project path.
+   */
+  async run() {
+    // get path of the templater
+    const templaterFullPath = this.fileService.join(
+      __dirname,
+      "../../assets/yargs-template/task-runner/templater.sh",
+    );
+
+    // get execution directory
+    const runnerDir = this.fileService.getRunnerDir();
+
+    // get project name user input
+    const projectName: string = await this.getProjectName();
+
+    // execute the templater from the runner directory and provide given name
+    const shCmd = `bash ${templaterFullPath} ${projectName}`;
+    this.spawnService.execSyncFromDir(shCmd, runnerDir);
+
+    this.setData({
+      outputDestination: this.fileService.join(runnerDir, projectName),
+    });
+  }
+
+  /**
+   * Resolves the project name input from args or prompt.
+   *
+   * @returns the project name string
+   */
+  async getProjectName(): Promise<string> {
+    let projectName: string;
+    if (this.argService.hasFlag(CLIOptions.name)) {
+      projectName = this.argService.getOption<string>(CLIOptions.name);
+    } else {
+      projectName = await this.promptService.getInput("Enter Project Name");
+    }
+    if (!projectName) {
+      throw new Error("Unable to resolve projectName");
+    }
+    return projectName;
+  }
+}

package/src/tasks/generate/generate-command.ts

@@ -0,0 +1,136 @@
+import chalk from "chalk";
+import { AppTask } from "../../wrappers/app-task";
+import { autoInjectable } from "tsyringe";
+import { AppState, GenTargetType } from "../../types/state";
+import { FileService } from "../../services/file-service";
+import { UtilService } from "../../services/util-service";
+import { CaseType } from "../../types/format";
+import path from "path";
+import { getCommandTemplate } from "../../templates/command";
+import { ProjectService } from "../../services/project-service";
+import { PromptService } from "../../services/prompt-service";
+
+/**
+ * Generates a new command class
+ */
+@autoInjectable()
+export default class GenerateCommand extends AppTask {
+  loggerName = "Generate Command";
+
+  constructor(
+    private fileService: FileService,
+    private utilService: UtilService,
+    private projectService: ProjectService,
+    private promptService: PromptService,
+  ) {
+    super();
+  }
+
+  /**
+   * Generates a new command class file.
+   *
+   * @returns updated state with outputDestination set to generated result path.
+   */
+  async run(): Promise<void | Partial<AppState>> {
+    const { utilService, fileService, projectService } = this;
+
+    if (this.state.data.genTargetType !== GenTargetType.Command) {
+      return; // no-op
+    }
+
+    this.logger.info(chalk.blueBright("Generating Command"));
+    const targetName = this.state.data.genTargetName!;
+    const targetDirectory = this.state.data.project!.commandDestination!;
+
+    // detect case between commands and task files
+    const convention = projectService.getConvention();
+    this.logger.debug(`Using convention: ${chalk.magentaBright(convention)}`);
+
+    const className = utilService.titleizedToCase(
+      targetName,
+      CaseType.PASCAL_CASE,
+    );
+    const filename = `${utilService.titleizedToCase(targetName, convention)}${ProjectService.defaults.extention}`;
+
+    const taskMappings = new Map();
+    await this.addTasksToMap(taskMappings);
+    const rendered = getCommandTemplate(className, taskMappings);
+    const destination = path.join(targetDirectory, filename);
+
+    // write contents
+    fileService.writeFile(destination, rendered);
+    return { data: { outputDestination: destination } };
+  }
+
+  /**
+   * Checks state for required fields. Executes prior to run method.
+   * Skips validation if genTargetType is not set to command.
+   */
+  async preRun() {
+    if (this.state.data.genTargetType !== GenTargetType.Command) {
+      return; // no validation on no-op flow
+    }
+    if (!this.state.data.genTargetName) {
+      throw new Error("Unable to determine targetName");
+    }
+    if (!this.state.data.project) {
+      throw new Error("Unable to determine project");
+    }
+    if (!this.state.data.project.commandDestination) {
+      throw new Error("Unable to determine targetDirectory");
+    }
+  }
+
+  /**
+   * Prompt to select tasks to use in the command being generated.
+   *
+   * @param taskMappings the map to add picked tasks to import for the command
+   */
+  async addTasksToMap(taskMappings: Map<string, string>) {
+    if (!this.state.data.project?.taskDestination) {
+      return;
+    }
+
+    const taskFiles = this.fileService.getFilesInDir(
+      this.state.data.project.taskDestination,
+    );
+
+    this.logger.debug(`Found ${taskFiles.length} task files`);
+    await this.logger.flush();
+
+    // prompt for tasks to use in the new command
+    const pickedTasks = await this.promptService.pickMultiple(
+      "Include Tasks",
+      taskFiles.map((tf) => ({
+        name: this.utilService.titleizedToCase(
+          this.utilService.titleizeAll(this.fileService.getFilenameNoExt(tf)),
+          CaseType.PASCAL_CASE,
+        ),
+        value: tf,
+      })),
+    );
+
+    this.logger.debug(`Selected ${pickedTasks.length} tasks`);
+    if (!pickedTasks.length) {
+      return;
+    }
+
+    // add them to the map
+    for (const picked of pickedTasks) {
+      const filename = this.fileService.getFilenameNoExt(picked);
+      const taskClassName = this.utilService.titleizedToCase(
+        this.utilService.titleizeAll(filename),
+        CaseType.PASCAL_CASE,
+      );
+      const relativeSource = this.state.data.project!.commandDestination!;
+      const relativeDest = picked;
+      taskMappings.set(
+        taskClassName,
+        this.fileService
+          .toRelativePath(relativeSource, relativeDest)
+          // remove extension for typescript import
+          .replace(ProjectService.defaults.extention, ""),
+      );
+    }
+  }
+}

package/src/tasks/generate/generate-service.ts

@@ -0,0 +1,78 @@
+import chalk from "chalk";
+import { AppTask } from "../../wrappers/app-task";
+import { autoInjectable } from "tsyringe";
+import { GenTargetType } from "../../types/state";
+import { ProjectService } from "../../services/project-service";
+import { UtilService } from "../../services/util-service";
+import { FileService } from "../../services/file-service";
+import { CaseType } from "../../types/format";
+import path from "path";
+import { getServiceTemplate } from "../../templates/service";
+
+/**
+ * Generates a new service class
+ */
+@autoInjectable()
+export default class GenerateService extends AppTask {
+  loggerName = "Generate Service";
+
+  constructor(
+    private projectService: ProjectService,
+    private utilService: UtilService,
+    private fileService: FileService,
+  ) {
+    super();
+  }
+
+  /**
+   * Generates a new service class file.
+   *
+   * @returns updated state with outputDestination set to generated result path.
+   */
+  async run() {
+    if (this.state.data.genTargetType !== GenTargetType.Service) {
+      return;
+    }
+
+    this.logger.info(chalk.blueBright("Generating Service"));
+    const { utilService, projectService } = this;
+
+    const targetName = this.state.data.genTargetName!;
+    const targetDirectory = this.state.data.project!.serviceDestination!;
+
+    // detect case
+    const convention = projectService.getConvention();
+    this.logger.debug(`Using convention: ${chalk.magentaBright(convention)}`);
+    const className = utilService.titleizedToCase(
+      targetName,
+      CaseType.PASCAL_CASE,
+    );
+
+    const rendered = getServiceTemplate(className);
+    const filename = `${utilService.titleizedToCase(targetName, convention)}${ProjectService.defaults.extention}`;
+    const destination = path.join(targetDirectory, filename);
+
+    // write contents
+    this.fileService.writeFile(destination, rendered);
+    return { data: { outputDestination: destination } };
+  }
+
+  /**
+   * Checks state for required fields. Executes prior to run method.
+   * Skips validation if genTargetType is not set to service.
+   */
+  async preRun() {
+    if (this.state.data.genTargetType !== GenTargetType.Service) {
+      return; // no validation on no-op flow
+    }
+    if (!this.state.data.genTargetName) {
+      throw new Error("Unable to determine targetName");
+    }
+    if (!this.state.data.project) {
+      throw new Error("Unable to determine project");
+    }
+    if (!this.state.data.project.serviceDestination) {
+      throw new Error("Unable to determine targetDirectory");
+    }
+  }
+}

package/src/tasks/generate/generate-task.ts

@@ -0,0 +1,79 @@
+import chalk from "chalk";
+import { AppTask } from "../../wrappers/app-task";
+import { autoInjectable } from "tsyringe";
+import { GenTargetType } from "../../types/state";
+import { getTaskTemplate } from "../../templates/task";
+import { CaseType } from "../../types/format";
+import { UtilService } from "../../services/util-service";
+import { FileService } from "../../services/file-service";
+import { ProjectService } from "../../services/project-service";
+import path from "path";
+
+/**
+ * Generates a new task class
+ */
+@autoInjectable()
+export default class GenerateTask extends AppTask {
+  loggerName = "Generate Task";
+
+  constructor(
+    private utilService: UtilService,
+    private fileService: FileService,
+    private projectService: ProjectService,
+  ) {
+    super();
+  }
+
+  /**
+   * Generates a new task class file.
+   *
+   * @returns updated state with outputDestination set to generated result path.
+   */
+  async run() {
+    if (this.state.data.genTargetType !== GenTargetType.Task) {
+      return;
+    }
+
+    const { utilService } = this;
+
+    this.logger.info(chalk.blueBright("Generating Task"));
+
+    const targetName = this.state.data.genTargetName!;
+    const targetDirectory = this.state.data.project!.taskDestination!;
+
+    // detect case
+    const convention = this.projectService.getConvention();
+    this.logger.debug(`Using convention: ${chalk.magentaBright(convention)}`);
+    const className = utilService.titleizedToCase(
+      targetName,
+      CaseType.PASCAL_CASE,
+    );
+
+    const rendered = getTaskTemplate(className);
+    const filename = `${utilService.titleizedToCase(targetName, convention)}${ProjectService.defaults.extention}`;
+    const destination = path.join(targetDirectory, filename);
+
+    // write contents
+    this.fileService.writeFile(destination, rendered);
+    return { data: { outputDestination: destination } };
+  }
+
+  /**
+   * Checks state for required fields. Executes prior to run method.
+   * Skips validation if genTargetType is not set to task.
+   */
+  async preRun() {
+    if (this.state.data.genTargetType !== GenTargetType.Task) {
+      return; // no validation on no-op flow
+    }
+    if (!this.state.data.genTargetName) {
+      throw new Error("Unable to determine targetName");
+    }
+    if (!this.state.data.project) {
+      throw new Error("Unable to determine project");
+    }
+    if (!this.state.data.project.taskDestination) {
+      throw new Error("Unable to determine targetDirectory");
+    }
+  }
+}

package/src/tasks/generate/select-gen-target-name.ts

@@ -0,0 +1,44 @@
+import chalk from "chalk";
+import { AppTask } from "../../wrappers/app-task";
+import { autoInjectable } from "tsyringe";
+import { PromptService } from "../../services/prompt-service";
+import { ProjectService } from "../../services/project-service";
+import { UtilService } from "../../services/util-service";
+
+/**
+ * SelectGenTargetName
+ */
+@autoInjectable()
+export default class SelectGenTargetName extends AppTask {
+  loggerName = "SelectGenTargetName";
+  constructor(
+    private promptService: PromptService,
+    private utilService: UtilService,
+  ) {
+    super();
+  }
+
+  async run() {
+    this.logger.info(chalk.blueBright("Checking Target Name"));
+
+    let targetName = this.argService.getTargetName();
+    if (!targetName) {
+      targetName =
+        (await this.promptService.getInput(
+          `Enter Name for ${chalk.blueBright(this.utilService.titleize(this.state.data.genTargetType!))}`,
+        )) || ProjectService.defaults.targetName;
+    }
+    if (!targetName) {
+      throw new Error("Unable to resolve targetName");
+    }
+    this.logger.debug(`Name selected: ${chalk.magentaBright(targetName)}`);
+    targetName = this.utilService.titleizeAll(targetName);
+    this.setData({ genTargetName: targetName });
+  }
+
+  async preRun() {
+    if (!this.state.data.genTargetType) {
+      throw new Error("Unable to determine genTargetType");
+    }
+  }
+}