task-script-support-cli 0.1.1

package/src/services/file-service.ts

@@ -0,0 +1,78 @@
+import chalk from "chalk";
+import fs from "node:fs";
+import path from "node:path";
+import { singleton } from "tsyringe";
+
+const ignoredDirectories = new Set(["node_modules", "dist"]);
+
+@singleton()
+export default class FileService {
+  getRunnerDir(): string {
+    return process.cwd();
+  }
+
+  getFilesInDir(dirPath: string): string[] {
+    if (!fs.existsSync(dirPath) || !fs.statSync(dirPath).isDirectory()) {
+      throw new Error(`Directory not found: ${dirPath}`);
+    }
+    return fs.readdirSync(dirPath);
+  }
+
+  getRunnerRootDir(): string {
+    let currentDir = this.getRunnerDir();
+    while (currentDir !== "/") {
+      if (fs.existsSync(path.join(currentDir, "package.json"))) {
+        return currentDir;
+      }
+      currentDir = path.dirname(currentDir);
+    }
+    throw new Error(
+      `Unable to find project root! ${chalk.dim("(missing package.json?)")}`,
+    );
+  }
+
+  getTaskDirs(startPath: string): string[] {
+    return this.findDirsByName(startPath, "tasks");
+  }
+
+  getServiceDirs(startPath: string): string[] {
+    return this.findDirsByName(startPath, "services");
+  }
+
+  getCommandDirs(startPath: string): string[] {
+    return this.findDirsByName(startPath, "commands");
+  }
+
+  writeFile(filePath: string, content: string): void {
+    const dirPath = path.dirname(filePath);
+    if (!fs.existsSync(dirPath)) {
+      throw new Error(`Directory not found: ${chalk.magentaBright(dirPath)}`);
+    }
+    if (fs.existsSync(filePath)) {
+      throw new Error(`File already exists: ${chalk.magentaBright(filePath)}`);
+    }
+    fs.writeFileSync(filePath, content, "utf-8");
+  }
+
+  private findDirsByName(dirPath: string, dirNameSuffix: string): string[] {
+    const dirs: string[] = [];
+    this.traverseDir(dirPath, (dir) => {
+      if (path.basename(dir).includes(dirNameSuffix) && !dirs.includes(dir)) {
+        dirs.push(dir);
+      }
+    });
+    return dirs;
+  }
+
+  private traverseDir(dirPath: string, callback: (dir: string) => void) {
+    const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(dirPath, entry.name);
+      if (entry.isDirectory() && !ignoredDirectories.has(entry.name)) {
+        this.traverseDir(fullPath, callback);
+      } else {
+        callback(path.dirname(fullPath));
+      }
+    }
+  }
+}

package/src/services/log-service.ts

@@ -0,0 +1,43 @@
+import { inject, injectable } from "tsyringe";
+import { PinoLogger } from "task-script-support";
+import pino from "pino";
+
+@injectable()
+export class LogService {
+  logger: pino.Logger;
+
+  static ParentInstance?: pino.Logger;
+
+  constructor(@inject("PinoLogger") private pinoLogger: PinoLogger) {
+    if (!LogService.ParentInstance) {
+      this.logger = pinoLogger.getLogger();
+      LogService.ParentInstance = this.logger;
+    } else {
+      this.logger = LogService.ParentInstance.child({});
+    }
+  }
+
+  setPrefix(prefix: string) {
+    this.logger = this.pinoLogger.getLogger(prefix);
+  }
+
+  public info(msg: string, obj?: unknown): void {
+    this.logger.info(obj, msg);
+  }
+
+  public error(err: Error | string, msg?: string, obj?: unknown): void {
+    if (err instanceof Error) {
+      this.logger.error({ err, ...(obj ? obj : {}) }, msg || "Error occurred");
+    } else {
+      this.logger.error(obj, `${msg}: ${err}`);
+    }
+  }
+
+  public warn(msg: string, obj?: unknown): void {
+    this.logger.warn(obj, msg);
+  }
+
+  public debug(msg: string, obj?: unknown): void {
+    this.logger.debug(obj, msg);
+  }
+}

package/src/services/project-service.ts

@@ -0,0 +1,72 @@
+import { autoInjectable } from "tsyringe";
+import FileService from "./file-service";
+import { CaseType } from "../types/format";
+import { UtilService } from "./util-service";
+
+@autoInjectable()
+export default class ProjectService {
+  static defaults = {
+    targetName: "Foo-Bar-Baz",
+    sampleFile: "test-file.ts",
+    convention: CaseType.PASCAL_CASE,
+    extention: ".ts",
+  };
+
+  constructor(
+    private fileService: FileService,
+    private utilService: UtilService,
+  ) {}
+
+  /**
+   * Get all task files found in the project
+   *
+   * @returns a string[] of task filenames found in the project the script was executed in.
+   */
+  getTaskFiles() {
+    const runnerRoot = this.fileService.getRunnerRootDir();
+    const taskFolders = this.fileService.getTaskDirs(runnerRoot);
+
+    // return available task filenames
+    return taskFolders.flatMap((f) => this.fileService.getFilesInDir(f));
+  }
+
+  private getSourceFiles() {
+    const runnerRoot = this.fileService.getRunnerRootDir();
+
+    return [
+      ...this.fileService
+        .getTaskDirs(runnerRoot)
+        .flatMap((dirPath) => this.fileService.getFilesInDir(dirPath)),
+      ...this.fileService
+        .getCommandDirs(runnerRoot)
+        .flatMap((dirPath) => this.fileService.getFilesInDir(dirPath)),
+      ...this.fileService
+        .getServiceDirs(runnerRoot)
+        .flatMap((dirPath) => this.fileService.getFilesInDir(dirPath)),
+    ];
+  }
+
+  /**
+   * Looks for a naming convention on the given filename array. Returns
+   * the first found convention or the default one if it can't be detected.
+   *
+   * @param existingFiles the files to check for a convention on.
+   * @returns
+   */
+  getConvention(): CaseType {
+    const existingFiles: string[] = this.getSourceFiles();
+
+    if (!existingFiles || !existingFiles.length)
+      return ProjectService.defaults.convention;
+    let convention: CaseType | null = null;
+    for (const file of existingFiles) {
+      convention = this.utilService.detectCase(file);
+      if (convention !== null) {
+        break;
+      }
+    }
+    return convention || ProjectService.defaults.convention;
+  }
+}
+
+export type ProjectDefaultsKey = keyof typeof ProjectService.defaults;

package/src/services/spawn-service.ts

@@ -0,0 +1,73 @@
+import childProcess, { ChildProcess, spawn } from "node:child_process";
+import type { ProcessStatus } from "../types/process";
+import { singleton } from "tsyringe";
+
+@singleton()
+export class SpawnService {
+  execSync(command: string) {
+    try {
+      return childProcess.execSync(command).toString();
+    } catch (error) {
+      console.error(`Error executing command: ${command}`);
+      throw error;
+    }
+  }
+
+  exec(command: string) {
+    try {
+      return childProcess.exec(command).toString();
+    } catch (error) {
+      console.error(`Error executing command: ${command}`, error);
+      throw error;
+    }
+  }
+
+  backgroundExec(command: string, args: string[] = []): ChildProcess {
+    const child = spawn(command, args, {
+      detached: true,
+      stdio: "ignore",
+    });
+
+    child.unref();
+    return child;
+  }
+
+  isProcessCompleted(pid: number): boolean {
+    try {
+      // sending signal 0 checks if the process exists
+      process.kill(pid, 0);
+      return false;
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    } catch (error) {
+      return true;
+    }
+  }
+
+  kill(pid: number) {
+    try {
+      process.kill(pid);
+    } catch (error) {
+      throw new Error(
+        `Failed to kill process with PID ${pid}: ${(error as Error).message}`,
+      );
+    }
+  }
+
+  forceKill(pid: number) {
+    try {
+      process.kill(pid, "SIGKILL");
+    } catch (error) {
+      throw new Error(
+        `Failed to forcefully kill process with PID ${pid}: ${(error as Error).message}`,
+      );
+    }
+  }
+
+  async getProcessStatus(pid: number): Promise<ProcessStatus> {
+    const completed = this.isProcessCompleted(pid);
+    return {
+      pid,
+      status: completed ? "completed" : "running",
+    };
+  }
+}

package/src/services/updater-service.ts

@@ -0,0 +1,9 @@
+import { singleton } from "tsyringe";
+
+/**
+ * UpdaterService
+ */
+@singleton()
+export default class UpdaterService {
+  constructor() {}
+}

package/src/services/util-service.ts

@@ -0,0 +1,87 @@
+import { singleton, container } from "tsyringe";
+import pkgJson from "../../package.json";
+import { CommandService, PinoLogger } from "task-script-support";
+import { AppStateData } from "../types/state";
+import { CLIArg } from "../types/process";
+import { CaseType } from "../types/format";
+
+@singleton()
+export class UtilService {
+  static TEXT_BREAKPONT: RegExp = /[. _-]/g;
+
+  /**
+   * Register external dependencies as injectables
+   */
+  static initializeDependencies() {
+    UtilService.registerCommandService();
+    UtilService.registerPinoService();
+  }
+
+  static titleize = (s: string) =>
+    s ? `${s[0]?.toUpperCase()}${s.slice(1, s.length)}` : s;
+  titleize = (s: string) => UtilService.titleize(s);
+  titleizeAll = (s: string) => UtilService.titleizeAll(s);
+  static titleizeAll = (str: string) =>
+    str
+      .trim()
+      .split(UtilService.TEXT_BREAKPONT)
+      .map(UtilService.titleize)
+      .join(" ");
+
+  static getAppName = () => pkgJson.name;
+  getAppName = () => pkgJson.name;
+
+  static getAppVersion = () => pkgJson.version;
+  getAppVersion = () => pkgJson.version;
+
+  static getAppDescription = () => pkgJson.description;
+  getAppDescription = () => pkgJson.description;
+
+  static registerCommandService() {
+    container.registerSingleton(CommandService<AppStateData, CLIArg[]>);
+
+    // configure args provider
+    const command = container.resolve(CommandService<AppStateData, CLIArg[]>);
+    command.argsProvider = (...cliArgs: unknown[]) => {
+      const args = command.argsProvider_Commander(...cliArgs);
+      container.registerInstance("Args", args);
+      return args;
+    };
+  }
+
+  static registerPinoService() {
+    container.registerInstance("PinoLogger", new PinoLogger());
+  }
+
+  titleizedToCase(str: string, targetCase: CaseType) {
+    switch (targetCase) {
+      case CaseType.KEBAB_CASE:
+        return str.toLowerCase().replace(UtilService.TEXT_BREAKPONT, "-");
+      case CaseType.SNAKE_CASE:
+        return str.toLowerCase().replace(UtilService.TEXT_BREAKPONT, "_");
+      case CaseType.CAMEL_CASE:
+        return `${str[0]?.toLowerCase()}${str.slice(1).replace(UtilService.TEXT_BREAKPONT, "")}`;
+      case CaseType.PASCAL_CASE:
+        return str.replace(UtilService.TEXT_BREAKPONT, "");
+      default:
+        throw new Error("Unsupported target case type.");
+    }
+  }
+
+  detectCase(filename: string): CaseType | null {
+    if (/^[A-Z][a-zA-Z]*[.](ts|js)$/.test(filename)) {
+      return CaseType.PASCAL_CASE;
+    }
+    if (/^[a-z]+(-[a-z]+)+[.](ts|js)$/.test(filename)) {
+      return CaseType.KEBAB_CASE;
+    }
+    if (/^[a-z]+(_[a-z]+)+[.](ts|js)$/.test(filename)) {
+      return CaseType.SNAKE_CASE;
+    }
+    if (/^[a-z]+([A-Z][a-z]*)*[.](ts|js)$/.test(filename)) {
+      return CaseType.CAMEL_CASE;
+    }
+
+    return null;
+  }
+}

package/src/tasks/check-env.ts

@@ -0,0 +1,125 @@
+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 path from "path";
+
+/**
+ * Checks the environment configuration
+ */
+@autoInjectable()
+export default class CheckEnvironment extends AppTask {
+  loggerName = "Check Environment";
+
+  requiredEnvVars: string[] = [];
+
+  optionalEnvVars = [
+    EnvironmentConfigKeys.NODE_ENV,
+    EnvironmentConfigKeys.PINO_LOG_TARGET,
+    EnvironmentConfigKeys.PINO_LOG_DIR_PATH,
+    EnvironmentConfigKeys.PINO_LOG_FILENAME,
+    EnvironmentConfigKeys.PINO_LOG_LEVEL,
+  ];
+
+  constructor(private fileService: FileService) {
+    super();
+  }
+
+  async run() {
+    this.logger.info(chalk.blueBright("Running Check Environment"));
+
+    const envVars = [...this.optionalEnvVars, ...this.requiredEnvVars];
+    this.getReadMessages(envVars).forEach((m) => this.logger.debug(m));
+    const errors: string[] = this.getErrorMessages(this.requiredEnvVars);
+    this.checkToExit(errors);
+
+    try {
+      const projectDir = this.fileService.getRunnerRootDir();
+      this.checkProjectDependencies(projectDir, errors);
+      this.checkProjectDirectories(projectDir, errors);
+    } catch (err) {
+      errors.push(`Unexpected error checking project: ${err}`);
+    }
+
+    this.checkToExit(errors);
+    this.setData({ environmentValidated: true });
+  }
+
+  /**
+   * Check for the folders we need to generate files in. Add errors
+   * when no target directories can be found.
+   *
+   * @param projectDir the target project root directory path
+   * @param errors string array error messages are added to
+   */
+  checkProjectDirectories(projectDir: string, errors: string[]) {
+    const directories = {
+      taskFolders: this.fileService.getTaskDirs(projectDir),
+      serviceFolders: this.fileService.getServiceDirs(projectDir),
+      commandFolders: this.fileService.getCommandDirs(projectDir),
+    };
+    Object.keys(directories).forEach((k: string) => {
+      const key: keyof typeof directories = k as keyof typeof directories;
+      if (!directories[key] || !directories[key].length) {
+        errors.push(`Unable to find any ${k} in project`);
+      }
+    });
+  }
+
+  /**
+   * Check that the project has the right dependencies installed. Adds
+   * to the errors array when they can't be found.
+   *
+   * @param projectDir the target project root directory path
+   * @param errors string array error messages are added to
+   */
+  checkProjectDependencies(projectDir: string, errors: string[]) {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const packagePath = require(path.join(projectDir, "package.json"));
+    const requireDeps = ["task-script-support", "tsyringe"];
+    requireDeps.forEach((d) => {
+      if (!Object.keys(packagePath.dependencies || {}).includes(d)) {
+        errors.push(`Missing required dependencies in project: '${d}'`);
+      }
+    });
+  }
+
+  /**
+   * Log and exit program if errors are present.
+   *
+   * @param errors the error messages array to check
+   */
+  private checkToExit(errors: string[]) {
+    if (errors.length) {
+      this.logEnvErrors(errors);
+      process.exit(1);
+    }
+  }
+
+  /**
+   * Logs any error messages in the provided array.
+   *
+   * @param errors the error messages array to log
+   */
+  private logEnvErrors(errors: string[]): void {
+    if (errors.length) {
+      this.logger.error(
+        new Error("Misconfigured Environment"),
+        chalk.red(errors.join("\n")),
+      );
+    }
+  }
+
+  private getReadMessages = (allEnvVars: string[]) =>
+    allEnvVars
+      .filter((e) => !!process.env[e])
+      .map(
+        (e) => `Read value for ${e}: ${chalk.magentaBright(process.env[e])}`,
+      );
+
+  private getErrorMessages = (reqEnvVars: string[]) =>
+    reqEnvVars
+      .filter((e) => !process.env[e])
+      .map((e) => `Missing required environment variable ${e}`);
+}

package/src/tasks/generate-command.ts

@@ -0,0 +1,87 @@
+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";
+
+/**
+ * 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,
+  ) {
+    super();
+  }
+
+  async run(): Promise<void | Partial<AppState>> {
+    const { utilService, fileService, argService, projectService } = this;
+
+    if (this.state.data.genTargetType !== GenTargetType.Command) {
+      return;
+    }
+
+    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");
+    }
+
+    // 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 rendered = getCommandTemplate(className, taskMappings);
+    const filename = `${utilService.titleizedToCase(targetName, convention)}${ProjectService.defaults.extention}`;
+    const destination = path.join(targetDirectory, filename);
+
+    // write contents
+    fileService.writeFile(destination, rendered);
+    return { data: { outputDestination: destination } };
+  }
+
+  /**
+   * Get the target directory to save the generated file.
+   *
+   * @returns the destination path of the parent folder to save the new file in.
+   */
+  getTargetDirectory() {
+    const runnerRoot = this.fileService.getRunnerRootDir();
+    const commandFolders = this.fileService.getCommandDirs(runnerRoot);
+
+    if (commandFolders.length === 1) {
+      return commandFolders[0];
+    }
+
+    // TODO: prompt to select destination from available commandFolders
+    return commandFolders[0];
+  }
+}

package/src/tasks/generate-service.ts

@@ -0,0 +1,82 @@
+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();
+  }
+
+  async run() {
+    if (this.state.data.genTargetType !== GenTargetType.Service) {
+      return;
+    }
+
+    this.logger.info(chalk.blueBright("Generating Service"));
+    const { argService, 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");
+    }
+
+    // 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 } };
+  }
+
+  /**
+   * Get the target directory to save the generated file.
+   *
+   * @returns the destination path of the parent folder to save the new file in.
+   */
+  getTargetDirectory() {
+    const runnerRoot = this.fileService.getRunnerRootDir();
+    const servicesFolders = this.fileService.getServiceDirs(runnerRoot);
+
+    if (servicesFolders.length === 1) {
+      return servicesFolders[0];
+    }
+
+    // TODO: prompt to select destination from available servicesFolders
+    this.logger.warn(`Multiple service folders detected. Using first found.`);
+    return servicesFolders[0];
+  }
+}