task-script-support-cli 0.1.1 → 0.2.3

package/src/index.ts

@@ -13,6 +13,7 @@ UtilService.initializeDependencies();
 
 import { AboutCommand } from "./commands/about";
 import { GenCommand } from "./commands/gen";
+import { NewCommand } from "./commands/new";
 
 const { program } = commander;
 const name = UtilService.getAppName();
@@ -35,4 +36,10 @@ program
   .option("-t, --task", "Generate a task")
   .action(container.resolve(GenCommand).handler);
 
+program
+  .command("new")
+  .option("-n, --name <name>", "Name of the New Project")
+  // .option("-d, --dest", "target destination path")
+  .action(container.resolve(NewCommand).handler);
+
 program.parse(process.argv);

package/src/services/cache-service.ts

@@ -0,0 +1,50 @@
+import nodePersist from "node-persist";
+import { singleton } from "tsyringe";
+import { ProjectConfig } from "../types/project";
+import _ from "lodash";
+import chalk from "chalk";
+import { LogService } from "./log-service";
+import path from "path";
+
+@singleton()
+export class CacheService {
+  private storageInitialized = false;
+  constructor(private logger: LogService) {
+    logger.setPrefix(`${this.constructor.name} :: `);
+  }
+
+  async initialize() {
+    if (this.storageInitialized) {
+      return;
+    }
+    const appDataFolder =
+      process.env.APPDATA ||
+      (process.platform === "darwin"
+        ? `${process.env.HOME}/Library/Preferences`
+        : `${process.env.HOME}/.config`);
+
+    const location = path.join(appDataFolder, "tssc");
+    this.logger.debug(chalk.dim(`Using cache: ${location}`));
+
+    await nodePersist.init({ dir: location });
+    this.storageInitialized = true;
+  }
+
+  async getProject(rootDir: string): Promise<ProjectConfig | null> {
+    await this.initialize();
+    const project = await nodePersist.getItem(rootDir);
+    return project;
+  }
+
+  async writeProject(project: ProjectConfig): Promise<void> {
+    await this.initialize();
+    const projectKeys: (keyof ProjectConfig)[] = [
+      "rootDir",
+      "taskDestination",
+      "serviceDestination",
+      "commandDestination",
+    ];
+    const cleanedProject: ProjectConfig = _.pick(project, projectKeys);
+    await nodePersist.setItem(project.rootDir, cleanedProject);
+  }
+}

package/src/services/file-service.ts

@@ -6,11 +6,28 @@ import { singleton } from "tsyringe";
 const ignoredDirectories = new Set(["node_modules", "dist"]);
 
 @singleton()
-export default class FileService {
+export class FileService {
   getRunnerDir(): string {
     return process.cwd();
   }
 
+  join(path1: string, path2: string) {
+    return path.join(path1, path2);
+  }
+
+  toRelativePath(fromPath: string, toPath: string) {
+    return path.relative(fromPath, toPath);
+  }
+
+  toFullPath(relativePath: string) {
+    return path.resolve(relativePath);
+  }
+
+  getFilenameNoExt(somePath: string) {
+    const filename = path.basename(somePath);
+    return filename.includes(".") ? filename.split(".")[0] || "" : filename;
+  }
+
   getFilesInDir(dirPath: string): string[] {
     if (!fs.existsSync(dirPath) || !fs.statSync(dirPath).isDirectory()) {
       throw new Error(`Directory not found: ${dirPath}`);

package/src/services/log-service.ts

@@ -18,7 +18,12 @@ export class LogService {
   }
 
   setPrefix(prefix: string) {
-    this.logger = this.pinoLogger.getLogger(prefix);
+    if (!LogService.ParentInstance) {
+      this.logger = this.pinoLogger.getLogger(prefix);
+      LogService.ParentInstance = this.logger;
+    } else {
+      this.logger = LogService.ParentInstance.child({}, { msgPrefix: prefix });
+    }
   }
 
   public info(msg: string, obj?: unknown): void {

package/src/services/project-service.ts

@@ -1,10 +1,10 @@
 import { autoInjectable } from "tsyringe";
-import FileService from "./file-service";
+import { FileService } from "./file-service";
 import { CaseType } from "../types/format";
 import { UtilService } from "./util-service";
 
 @autoInjectable()
-export default class ProjectService {
+export class ProjectService {
   static defaults = {
     targetName: "Foo-Bar-Baz",
     sampleFile: "test-file.ts",

package/src/services/prompt-service.ts

@@ -0,0 +1,60 @@
+import { autoInjectable } from "tsyringe";
+import { UtilService } from "./util-service";
+
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const { search, input, checkbox } = 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(200);
+
+    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;
+  }
+
+  async getInput(message: string, required: boolean = true) {
+    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[]> {
+    return await checkbox({
+      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/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";
+
+/**
+ * CreateNewProject
+ */
+@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-command.ts

@@ -2,12 +2,13 @@ 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 { 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 { ProjectService } from "../services/project-service";
+import { PromptService } from "../services/prompt-service";
 
 /**
  * Generates a new command class
@@ -20,47 +21,40 @@ export default class GenerateCommand extends AppTask {
     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, argService, projectService } = this;
+    const { utilService, fileService, projectService } = this;
 
     if (this.state.data.genTargetType !== GenTargetType.Command) {
-      return;
+      return; // no-op
     }
 
     this.logger.info(chalk.blueBright("Generating Command"));
-
-    let targetName = argService.getTargetName();
-    if (!targetName) {
-      // TODO: Should we prompt for target name here?
-      targetName = argService.cleanTargetName(
-        ProjectService.defaults.targetName,
-      );
-    }
-
-    const targetDirectory = this.getTargetDirectory();
-    if (!targetDirectory) {
-      throw new Error("Unable to determine target Directory");
-    }
+    const targetName = this.state.data.genTargetName!;
+    const targetDirectory = this.state.data.project!.commandDestination!;
 
     // detect case between commands and task files
-    const taskFiles = projectService.getTaskFiles();
     const convention = projectService.getConvention();
     this.logger.debug(`Using convention: ${chalk.magentaBright(convention)}`);
 
-    this.logger.debug(`Found ${taskFiles.length} task files`);
     const className = utilService.titleizedToCase(
       targetName,
       CaseType.PASCAL_CASE,
     );
-    // TODO: prompt for tasks to use in the new command?
-    const taskMappings = new Map();
+    const filename = `${utilService.titleizedToCase(targetName, convention)}${ProjectService.defaults.extention}`;
 
+    const taskMappings = new Map();
+    await this.addTasksToMap(taskMappings);
     const rendered = getCommandTemplate(className, taskMappings);
-    const filename = `${utilService.titleizedToCase(targetName, convention)}${ProjectService.defaults.extention}`;
     const destination = path.join(targetDirectory, filename);
 
     // write contents
@@ -69,19 +63,78 @@ export default class GenerateCommand extends AppTask {
   }
 
   /**
-   * Get the target directory to save the generated file.
+   * 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.
    *
-   * @returns the destination path of the parent folder to save the new file in.
+   * @param taskMappings the map to add picked tasks to import for the command
    */
-  getTargetDirectory() {
-    const runnerRoot = this.fileService.getRunnerRootDir();
-    const commandFolders = this.fileService.getCommandDirs(runnerRoot);
+  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`);
+
+    // 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,
+      })),
+    );
 
-    if (commandFolders.length === 1) {
-      return commandFolders[0];
+    this.logger.debug(`Selected ${pickedTasks.length} tasks`);
+    if (!pickedTasks.length) {
+      return;
     }
 
-    // TODO: prompt to select destination from available commandFolders
-    return commandFolders[0];
+    console.log(JSON.stringify(pickedTasks));
+
+    // 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 = this.fileService.join(
+        this.state.data.project.taskDestination,
+        picked,
+      );
+      taskMappings.set(
+        taskClassName,
+        this.fileService
+          .toRelativePath(relativeSource, relativeDest)
+          // remove extension for typescript import
+          .replace(ProjectService.defaults.extention, ""),
+      );
+    }
   }
 }

package/src/tasks/generate-service.ts

@@ -2,9 +2,9 @@ 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 { ProjectService } from "../services/project-service";
 import { UtilService } from "../services/util-service";
-import FileService from "../services/file-service";
+import { FileService } from "../services/file-service";
 import { CaseType } from "../types/format";
 import path from "path";
 import { getServiceTemplate } from "../templates/service";
@@ -24,26 +24,21 @@ export default class GenerateService extends AppTask {
     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 { argService, utilService, projectService } = this;
+    const { utilService, projectService } = this;
 
-    let targetName = argService.getTargetName();
-    if (!targetName) {
-      // TODO: Prompt for target name?
-      targetName = argService.cleanTargetName(
-        ProjectService.defaults.targetName,
-      );
-    }
-
-    const targetDirectory = this.getTargetDirectory();
-    if (!targetDirectory) {
-      throw new Error("Unable to determine target Directory");
-    }
+    const targetName = this.state.data.genTargetName!;
+    const targetDirectory = this.state.data.project!.serviceDestination!;
 
     // detect case
     const convention = projectService.getConvention();
@@ -63,20 +58,21 @@ export default class GenerateService extends AppTask {
   }
 
   /**
-   * Get the target directory to save the generated file.
-   *
-   * @returns the destination path of the parent folder to save the new file in.
+   * Checks state for required fields. Executes prior to run method.
+   * Skips validation if genTargetType is not set to service.
    */
-  getTargetDirectory() {
-    const runnerRoot = this.fileService.getRunnerRootDir();
-    const servicesFolders = this.fileService.getServiceDirs(runnerRoot);
-
-    if (servicesFolders.length === 1) {
-      return servicesFolders[0];
+  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");
     }
-
-    // TODO: prompt to select destination from available servicesFolders
-    this.logger.warn(`Multiple service folders detected. Using first found.`);
-    return servicesFolders[0];
   }
 }

package/src/tasks/generate-task.ts

@@ -5,8 +5,8 @@ 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 { FileService } from "../services/file-service";
+import { ProjectService } from "../services/project-service";
 import path from "path";
 
 /**
@@ -24,27 +24,22 @@ export default class GenerateTask extends AppTask {
     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, argService } = this;
+    const { utilService } = this;
 
     this.logger.info(chalk.blueBright("Generating Task"));
 
-    let targetName = argService.getTargetName();
-    if (!targetName) {
-      // TODO: Prompt for target name?
-      targetName = argService.cleanTargetName(
-        ProjectService.defaults.targetName,
-      );
-    }
-
-    const targetDirectory = this.getTargetDirectory();
-    if (!targetDirectory) {
-      throw new Error("Unable to determine target Directory");
-    }
+    const targetName = this.state.data.genTargetName!;
+    const targetDirectory = this.state.data.project!.taskDestination!;
 
     // detect case
     const convention = this.projectService.getConvention();
@@ -64,20 +59,21 @@ export default class GenerateTask extends AppTask {
   }
 
   /**
-   * Get the target directory to save the generated file.
-   *
-   * @returns the destination path of the parent folder to save the new file in.
+   * Checks state for required fields. Executes prior to run method.
+   * Skips validation if genTargetType is not set to task.
    */
-  getTargetDirectory() {
-    const runnerRoot = this.fileService.getRunnerRootDir();
-    const tasksFolders = this.fileService.getTaskDirs(runnerRoot);
-
-    if (tasksFolders.length === 1) {
-      return tasksFolders[0];
+  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");
     }
-
-    // TODO: prompt to select destination from available tasksFolders
-    this.logger.warn(`Multiple task folders detected. Using first found.`);
-    return tasksFolders[0];
   }
 }