task-script-support-cli 0.2.19 → 0.3.0

package/src/services/arg-service.ts

@@ -13,7 +13,8 @@ export class ArgService {
 
     const argObjects: ArgObject[] = [];
     for (const a of this.args) {
-      if (Array.isArray(a) || typeof a === "string") continue;
+      if (Array.isArray(a) || typeof a === "string" || a === undefined)
+        continue;
       argObjects.push(a);
     }
 
@@ -32,6 +33,7 @@ export class ArgService {
       throw new Error("Missing Arguments in ArgService!");
     }
     return this.args.find((arg) => {
+      if (arg === undefined) return false;
       if (typeof arg === "string") return false;
       if (Array.isArray(arg)) return false;
       return arg[flag] !== undefined;
@@ -42,9 +44,26 @@ export class ArgService {
     return UtilService.titleizeAll(name);
   }
 
+  hasPositionalArg(index: number = 0, typeOf: string = "string"): boolean {
+    return this.args!.length > index && typeof this.args![index] === typeOf;
+  }
+
+  getPositionalArg<T = string>(index: number = 0): T | undefined {
+    return this.args!.length > index ? (this.args![index] as T) : undefined;
+  }
+
+  getStringArg(): string | undefined {
+    if (this.hasPositionalArg(0, "string")) {
+      return this.getPositionalArg(0)!;
+    }
+    return undefined;
+  }
+
   getTargetName(): string | undefined {
     if (!this.hasFlag(CLIOptions.targetName)) {
-      return undefined;
+      return this.hasPositionalArg()
+        ? this.cleanTargetName(this.getStringArg()!)
+        : undefined;
     }
     const argInput = this.getOption(CLIOptions.targetName);
     return this.cleanTargetName(argInput);

package/src/services/file-service.ts

@@ -20,7 +20,8 @@ export class FileService {
   }
 
   toRelativePath(fromPath: string, toPath: string) {
-    return this.ensurePosix(path.relative(fromPath, toPath));
+    const p = this.ensurePosix(path.relative(fromPath, toPath));
+    return !p.includes("/") ? `./${p}` : p;
   }
 
   ensurePosix(possiblyWindowsPath: string) {

package/src/services/prompt-service.ts

@@ -63,7 +63,7 @@ export class PromptService {
     options: { name: string; value: T }[],
   ): Promise<T[]> {
     await this.utilService.sleep(800);
-    return await sortableCheckbox({
+    return sortableCheckbox({
       message,
       choices: options,
     });

package/src/services/spawn-service.ts

@@ -1,5 +1,4 @@
-import childProcess, { ChildProcess, spawn } from "node:child_process";
-import type { ProcessStatus } from "../types/process";
+import childProcess from "node:child_process";
 import { singleton } from "tsyringe";
 
 @singleton()
@@ -12,76 +11,4 @@ export class SpawnService {
       throw error;
     }
   }
-
-  execSync(command: string) {
-    try {
-      return childProcess.execSync(command).toString();
-    } catch (error) {
-      console.error(`Error executing command: ${command}`);
-      throw error;
-    }
-  }
-
-  exec(command: string) {
-    try {
-      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;
-    }
-  }
-
-  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/tasks/create-new-project.ts

@@ -51,6 +51,8 @@ export default class CreateNewProject extends AppTask {
     let projectName: string;
     if (this.argService.hasFlag(CLIOptions.name)) {
       projectName = this.argService.getOption<string>(CLIOptions.name);
+    } else if (this.argService.hasPositionalArg()) {
+      projectName = this.argService.getStringArg()!;
     } else {
       projectName = await this.promptService.getInput("Enter Project Name");
     }

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

@@ -1,35 +1,23 @@
 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";
+import GenerateAppTask from "../../wrappers/gen-app-task";
 
 /**
  * Generates a new command class
  */
 @autoInjectable()
-export default class GenerateCommand extends AppTask {
+export default class GenerateCommand extends GenerateAppTask {
   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.
+   * @returns updated state with outputDestination set to a generated result path.
    */
   async run(): Promise<void | Partial<AppState>> {
     const { utilService, fileService, projectService } = this;
@@ -52,9 +40,10 @@ export default class GenerateCommand extends AppTask {
     );
     const filename = `${utilService.titleizedToCase(targetName, convention)}${ProjectService.defaults.extention}`;
 
-    const taskMappings = new Map();
-    await this.addTasksToMap(taskMappings);
-    const rendered = getCommandTemplate(className, taskMappings);
+    const injectableMappings = new Map<string, string>();
+    await this.addTasksToMap(injectableMappings);
+
+    const rendered = getCommandTemplate(className, injectableMappings);
     const destination = path.join(targetDirectory, filename);
 
     // write contents
@@ -80,56 +69,4 @@ export default class GenerateCommand extends AppTask {
       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`);
-
-    // 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

@@ -1,33 +1,23 @@
 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";
+import GenerateAppTask from "../../wrappers/gen-app-task";
 
 /**
  * Generates a new service class
  */
 @autoInjectable()
-export default class GenerateService extends AppTask {
+export default class GenerateService extends GenerateAppTask {
   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.
+   * @returns updated state with outputDestination set to a generated result path.
    */
   async run() {
     if (this.state.data.genTargetType !== GenTargetType.Service) {
@@ -48,7 +38,11 @@ export default class GenerateService extends AppTask {
       CaseType.PASCAL_CASE,
     );
 
-    const rendered = getServiceTemplate(className);
+    const injectableMappings = new Map<string, string>();
+    if (this.argService.hasFlag("inject")) {
+      await this.addServicesToMap(injectableMappings, targetDirectory);
+    }
+    const rendered = getServiceTemplate(className, injectableMappings);
     const filename = `${utilService.titleizedToCase(targetName, convention)}${ProjectService.defaults.extention}`;
     const destination = path.join(targetDirectory, filename);
 

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

@@ -1,33 +1,23 @@
 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";
+import GenAppTask from "../../wrappers/gen-app-task";
 
 /**
  * Generates a new task class
  */
 @autoInjectable()
-export default class GenerateTask extends AppTask {
+export default class GenerateTask extends GenAppTask {
   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.
+   * @returns updated state with outputDestination set to a generated result path.
    */
   async run() {
     if (this.state.data.genTargetType !== GenTargetType.Task) {
@@ -49,7 +39,11 @@ export default class GenerateTask extends AppTask {
       CaseType.PASCAL_CASE,
     );
 
-    const rendered = getTaskTemplate(className);
+    const injectableMappings = new Map<string, string>();
+    if (this.argService.hasFlag("inject")) {
+      await this.addServicesToMap(injectableMappings, targetDirectory);
+    }
+    const rendered = getTaskTemplate(className, injectableMappings);
     const filename = `${utilService.titleizedToCase(targetName, convention)}${ProjectService.defaults.extention}`;
     const destination = path.join(targetDirectory, filename);
 

package/src/templates/command.ts

@@ -1,3 +1,7 @@
+const nonClashingName = (name: string) => `${name}Task`;
+const nameCheck = (name: string, className: string) =>
+  name === className ? nonClashingName(name) : name;
+
 export const getCommandTemplate = (
   className: string,
   tasks: Map<string, string> = new Map(),
@@ -7,12 +11,16 @@ import { Command } from "../wrappers/command";
 ${tasks
   .keys()
   .toArray()
-  .map((k) => `import ${k} from "${tasks.get(k)}";`)
+  .map((k) => `import ${nameCheck(k, className)} from "${tasks.get(k)}";`)
   .join("\n")}
 
 @singleton()
 export class ${className} extends Command {
-  tasks = [${tasks.keys().toArray().join(", ")}];
+  tasks = [${tasks
+    .keys()
+    .toArray()
+    .map((k) => nameCheck(k, className))
+    .join(", ")}];
 }
 
 `;

package/src/templates/service.ts

@@ -1,5 +1,11 @@
-export const getServiceTemplate = (className: string) =>
-  `import { singleton } from "tsyringe";
+const camelCase = (s: string) => s.charAt(0).toLowerCase() + s.slice(1);
+
+export const getServiceTemplate = (
+  className: string,
+  injections: Map<string, string>,
+) => {
+  if (!injections || injections.size === 0) {
+    return `import { singleton } from "tsyringe";
 
 /**
  * ${className}
@@ -10,3 +16,29 @@ export class ${className} {
 }
 
 `;
+  }
+
+  return `import { singleton } from "tsyringe";
+${injections
+  .keys()
+  .toArray()
+  .map((k) => `import { ${k} } from "${injections.get(k)}";`)
+  .join("\n")}
+
+
+/**
+ * ${className}
+ */
+@singleton()
+export class ${className} {
+  constructor(
+    ${injections
+      .keys()
+      .toArray()
+      .map((k) => `private ${camelCase(k)}: ${k}`)
+      .join(",\n    ")}
+  ) {}
+}
+
+`;
+};

package/src/templates/task.ts

@@ -1,6 +1,34 @@
-export const getTaskTemplate = (className: string) =>
-  `import { AppTask } from "../wrappers/app-task";
+const camelCase = (s: string) => s.charAt(0).toLowerCase() + s.slice(1);
+
+export const getTaskTemplate = (
+  className: string,
+  injections: Map<string, string>,
+) => {
+  if (!injections || injections.size === 0) {
+    return `import { AppTask } from "../wrappers/app-task";
+import { autoInjectable } from "tsyringe";
+
+/**
+ * ${className}
+ */
+@autoInjectable()
+export default class ${className} extends AppTask {
+  loggerName = "${className}";
+  async run() {
+    // TODO: implement task
+  }
+}
+
+`;
+  }
+
+  return `import { AppTask } from "../wrappers/app-task";
 import { autoInjectable } from "tsyringe";
+${injections
+  .keys()
+  .toArray()
+  .map((k) => `import { ${k} } from "${injections.get(k)}";`)
+  .join("\n")}
 
 /**
  * ${className}
@@ -8,9 +36,21 @@ import { autoInjectable } from "tsyringe";
 @autoInjectable()
 export default class ${className} extends AppTask {
   loggerName = "${className}";
+  
+  constructor(
+    ${injections
+      .keys()
+      .toArray()
+      .map((k) => `private ${camelCase(k)}: ${k}`)
+      .join(",\n    ")}
+  ) {
+    super();
+  }
+  
   async run() {
     // TODO: implement task
   }
 }
 
 `;
+};

package/src/types/project.ts

@@ -10,3 +10,8 @@ export interface ProjectData {
   serviceFolders: string[];
   commandFolders: string[];
 }
+
+export type ProjectImport = {
+  importClassName: string;
+  importPath: string;
+};

package/src/wrappers/gen-app-task.ts

@@ -0,0 +1,150 @@
+import { AppTask } from "./app-task";
+import { autoInjectable } from "tsyringe";
+import { CaseType } from "../types/format";
+import { UtilService } from "../services/util-service";
+import { FileService } from "../services/file-service";
+import { ProjectService } from "../services/project-service";
+import { PromptService } from "../services/prompt-service";
+import { ProjectImport } from "../types/project";
+
+/**
+ * Generation Task Type
+ */
+@autoInjectable()
+export default class GenAppTask extends AppTask {
+  constructor(
+    protected utilService: UtilService,
+    protected fileService: FileService,
+    protected projectService: ProjectService,
+    protected promptService: PromptService,
+  ) {
+    super();
+  }
+
+  /**
+   * 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`);
+    const pickedTasks = await this.promptForImports("Include Tasks", taskFiles);
+
+    this.logger.debug(`Selected ${pickedTasks.length} tasks`);
+    if (!pickedTasks.length) {
+      return;
+    }
+    // add them to the map
+    this.formalizeImports(
+      pickedTasks,
+      this.state.data.project!.commandDestination!,
+    ).forEach((i: ProjectImport) =>
+      taskMappings.set(i.importClassName, i.importPath),
+    );
+  }
+
+  /**
+   * Prompt to select services to use in the command being generated.
+   *
+   * @param serviceMappings the map to add picked services to import for the command
+   * @param sourcePath the path to the parent directory of the source file being
+   *  generated to resolve relative paths for imports
+   */
+  async addServicesToMap(
+    serviceMappings: Map<string, string>,
+    sourcePath: string,
+  ) {
+    if (!this.state.data.project?.serviceDestination) {
+      return;
+    }
+
+    const serviceFiles = this.fileService.getFilesInDir(
+      this.state.data.project.serviceDestination,
+    );
+
+    this.logger.debug(`Found ${serviceFiles.length} service files`);
+    const pickedServices = await this.promptForImports(
+      "Include Services",
+      serviceFiles,
+    );
+
+    this.logger.debug(`Selected ${pickedServices.length} services`);
+    if (!pickedServices.length) {
+      return;
+    }
+    // add them to the map
+    this.formalizeImports(pickedServices, sourcePath).forEach(
+      (i: ProjectImport) =>
+        serviceMappings.set(i.importClassName, i.importPath),
+    );
+  }
+
+  /**
+   * Formalize the selected imports into a format that can be used in the source code being generated.
+   *
+   * 1. Generate a PascalCased import name from the filename
+   * 2. Convert to a relative path
+   * 3. Remove the file extension for TypeScript import
+   *
+   * @param selectedPaths the selected file paths to formalize
+   * @param relativeSource the path to the source file being generated to resolve relative paths
+   * @returns the formalized ProjectImport array ({ importClassName, importPath })
+   */
+  private formalizeImports(
+    selectedPaths: string[],
+    relativeSource: string,
+  ): ProjectImport[] {
+    if (!selectedPaths?.length) {
+      return [];
+    }
+    const formalizedPaths: ProjectImport[] = [];
+    for (const fullPath of selectedPaths) {
+      const filename = this.fileService.getFilenameNoExt(fullPath);
+      const importClassName = this.utilService.titleizedToCase(
+        this.utilService.titleizeAll(filename),
+        CaseType.PASCAL_CASE,
+      );
+
+      formalizedPaths.push({
+        importClassName,
+        importPath: this.fileService
+          .toRelativePath(relativeSource, fullPath)
+          .replace(ProjectService.defaults.extention, ""),
+      });
+    }
+    return formalizedPaths;
+  }
+
+  /**
+   * Prompt to select imports to use in the class being generated.
+   *
+   * @param messagePrompt the prompt message to display
+   * @param filePaths the file paths to select from
+   * @returns the selected file paths
+   */
+  private async promptForImports(
+    messagePrompt: string,
+    filePaths: string[],
+  ): Promise<string[]> {
+    return await this.promptService.pickMultiple(
+      messagePrompt,
+      filePaths.map((filePath: string) => ({
+        name: this.utilService.titleizedToCase(
+          this.utilService.titleizeAll(
+            this.fileService.getFilenameNoExt(filePath),
+          ),
+          CaseType.PASCAL_CASE,
+        ),
+        value: filePath,
+      })),
+    );
+  }
+}