task-script-support-cli 0.3.0 → 0.3.2

package/src/services/templater-service.ts

@@ -4,6 +4,7 @@ import { autoInjectable } from "tsyringe";
 import { SpawnService } from "./spawn-service";
 import { LogService } from "./log-service";
 import { dockerIgnoreTemplate } from "../templates/docker-ignore";
+import chalk from "chalk";
 
 const gitignoreContent = `node_modules
 dist
@@ -78,11 +79,19 @@ export class TemplateService {
     }
   }
 
+  toLogPath(pathString: string) {
+    return path.relative(
+      process.cwd(),
+      pathString.replaceAll("task-runner", this.outputName),
+    );
+  }
+
   private async copyDirectories() {
     for (const folder of this.dirListToCopy) {
       const src = path.join(this.sourceDir, folder);
       const dest = path.join(this.destination, folder);
-      this.logger.debug(`Running Copy: cp -R ${src} ${dest}`);
+      // this.logger.debug(`Running Copy: cp -R ${src} ${dest}`);;
+      this.logger.debug(`Generating folder ${chalk.dim(this.toLogPath(dest))}`);
       fs.cpSync(src, dest, { recursive: true });
     }
   }
@@ -91,7 +100,8 @@ export class TemplateService {
     for (const filename of this.fileListToCopy) {
       const src = path.join(this.sourceDir, filename);
       const dest = path.join(this.destination, filename);
-      this.logger.debug(`Running Copy: cp ${src} ${dest}`);
+      // this.logger.debug(`Running Copy: cp ${src} ${dest}`);
+      this.logger.debug(`Generating file ${chalk.dim(this.toLogPath(dest))}`);
       fs.copyFileSync(src, dest);
     }
   }
@@ -135,7 +145,9 @@ export class TemplateService {
     const rename = (ext = "") => {
       const src = path.join(this.destination, `task-runner${ext}`);
       const dest = path.join(this.destination, `${this.outputName}${ext}`);
-      this.logger.debug(`Renaming task-runner to ${this.outputName}${ext}`);
+      this.logger.debug(
+        `Fixing references ${chalk.dim(`(${this.outputName}${ext})`)}`,
+      );
       fs.renameSync(src, dest);
     };
     rename();

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

@@ -5,15 +5,25 @@ import { CaseType } from "../../types/format";
 import path from "path";
 import { getCommandTemplate } from "../../templates/command";
 import { ProjectService } from "../../services/project-service";
-import GenerateAppTask from "../../wrappers/gen-app-task";
+import { AppTask } from "../../wrappers/app-task";
+import { FileService } from "../../services/file-service";
+import { UtilService } from "../../services/util-service";
 
 /**
  * Generates a new command class
  */
 @autoInjectable()
-export default class GenerateCommand extends GenerateAppTask {
+export default class GenerateCommand extends AppTask {
   loggerName = "Generate Command";
 
+  constructor(
+    private fileService: FileService,
+    private projectService: ProjectService,
+    private utilService: UtilService,
+  ) {
+    super();
+  }
+
   /**
    * Generates a new command class file.
    *
@@ -22,12 +32,12 @@ export default class GenerateCommand extends GenerateAppTask {
   async run(): Promise<void | Partial<AppState>> {
     const { utilService, fileService, projectService } = this;
 
-    if (this.state.data.genTargetType !== GenTargetType.Command) {
+    if (this.state.data.genData!.targetType !== GenTargetType.Command) {
       return; // no-op
     }
 
     this.logger.info(chalk.blueBright("Generating Command"));
-    const targetName = this.state.data.genTargetName!;
+    const targetName = this.state.data.genData!.targetName!;
     const targetDirectory = this.state.data.project!.commandDestination!;
 
     // detect case between commands and task files
@@ -40,10 +50,10 @@ export default class GenerateCommand extends GenerateAppTask {
     );
     const filename = `${utilService.titleizedToCase(targetName, convention)}${ProjectService.defaults.extention}`;
 
-    const injectableMappings = new Map<string, string>();
-    await this.addTasksToMap(injectableMappings);
-
-    const rendered = getCommandTemplate(className, injectableMappings);
+    const injectablesMap = this.projectService.getImportMap(
+      this.state.data.genData!,
+    );
+    const rendered = getCommandTemplate(className, injectablesMap);
     const destination = path.join(targetDirectory, filename);
 
     // write contents
@@ -53,13 +63,13 @@ export default class GenerateCommand extends GenerateAppTask {
 
   /**
    * Checks state for required fields. Executes prior to run method.
-   * Skips validation if genTargetType is not set to command.
+   * Skips validation if genData.targetType is not set to command.
    */
   async preRun() {
-    if (this.state.data.genTargetType !== GenTargetType.Command) {
+    if (this.state.data.genData!.targetType !== GenTargetType.Command) {
       return; // no validation on no-op flow
     }
-    if (!this.state.data.genTargetName) {
+    if (!this.state.data.genData!.targetName) {
       throw new Error("Unable to determine targetName");
     }
     if (!this.state.data.project) {

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

@@ -5,29 +5,39 @@ import { ProjectService } from "../../services/project-service";
 import { CaseType } from "../../types/format";
 import path from "path";
 import { getServiceTemplate } from "../../templates/service";
-import GenerateAppTask from "../../wrappers/gen-app-task";
+import { AppTask } from "../../wrappers/app-task";
+import { FileService } from "../../services/file-service";
+import { UtilService } from "../../services/util-service";
 
 /**
  * Generates a new service class
  */
 @autoInjectable()
-export default class GenerateService extends GenerateAppTask {
+export default class GenerateService extends AppTask {
   loggerName = "Generate Service";
 
+  constructor(
+    private fileService: FileService,
+    private projectService: ProjectService,
+    private utilService: UtilService,
+  ) {
+    super();
+  }
+
   /**
    * Generates a new service class file.
    *
    * @returns updated state with outputDestination set to a generated result path.
    */
   async run() {
-    if (this.state.data.genTargetType !== GenTargetType.Service) {
+    if (this.state.data.genData!.targetType !== GenTargetType.Service) {
       return;
     }
 
     this.logger.info(chalk.blueBright("Generating Service"));
     const { utilService, projectService } = this;
 
-    const targetName = this.state.data.genTargetName!;
+    const targetName = this.state.data.genData!.targetName!;
     const targetDirectory = this.state.data.project!.serviceDestination!;
 
     // detect case
@@ -38,10 +48,9 @@ export default class GenerateService extends GenerateAppTask {
       CaseType.PASCAL_CASE,
     );
 
-    const injectableMappings = new Map<string, string>();
-    if (this.argService.hasFlag("inject")) {
-      await this.addServicesToMap(injectableMappings, targetDirectory);
-    }
+    const injectableMappings = this.projectService.getImportMap(
+      this.state.data.genData!,
+    );
     const rendered = getServiceTemplate(className, injectableMappings);
     const filename = `${utilService.titleizedToCase(targetName, convention)}${ProjectService.defaults.extention}`;
     const destination = path.join(targetDirectory, filename);
@@ -53,13 +62,13 @@ export default class GenerateService extends GenerateAppTask {
 
   /**
    * Checks state for required fields. Executes prior to run method.
-   * Skips validation if genTargetType is not set to service.
+   * Skips validation if genData.targetType is not set to service.
    */
   async preRun() {
-    if (this.state.data.genTargetType !== GenTargetType.Service) {
+    if (this.state.data.genData!.targetType !== GenTargetType.Service) {
       return; // no validation on no-op flow
     }
-    if (!this.state.data.genTargetName) {
+    if (!this.state.data.genData!.targetName) {
       throw new Error("Unable to determine targetName");
     }
     if (!this.state.data.project) {

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

@@ -5,22 +5,32 @@ import { getTaskTemplate } from "../../templates/task";
 import { CaseType } from "../../types/format";
 import { ProjectService } from "../../services/project-service";
 import path from "path";
-import GenAppTask from "../../wrappers/gen-app-task";
+import { AppTask } from "../../wrappers/app-task";
+import { FileService } from "../../services/file-service";
+import { UtilService } from "../../services/util-service";
 
 /**
  * Generates a new task class
  */
 @autoInjectable()
-export default class GenerateTask extends GenAppTask {
+export default class GenerateTask extends AppTask {
   loggerName = "Generate Task";
 
+  constructor(
+    private fileService: FileService,
+    private projectService: ProjectService,
+    private utilService: UtilService,
+  ) {
+    super();
+  }
+
   /**
    * Generates a new task class file.
    *
    * @returns updated state with outputDestination set to a generated result path.
    */
   async run() {
-    if (this.state.data.genTargetType !== GenTargetType.Task) {
+    if (this.state.data.genData!.targetType !== GenTargetType.Task) {
       return;
     }
 
@@ -28,7 +38,7 @@ export default class GenerateTask extends GenAppTask {
 
     this.logger.info(chalk.blueBright("Generating Task"));
 
-    const targetName = this.state.data.genTargetName!;
+    const targetName = this.state.data.genData!.targetName!;
     const targetDirectory = this.state.data.project!.taskDestination!;
 
     // detect case
@@ -39,11 +49,10 @@ export default class GenerateTask extends GenAppTask {
       CaseType.PASCAL_CASE,
     );
 
-    const injectableMappings = new Map<string, string>();
-    if (this.argService.hasFlag("inject")) {
-      await this.addServicesToMap(injectableMappings, targetDirectory);
-    }
-    const rendered = getTaskTemplate(className, injectableMappings);
+    const injectablesMap = this.projectService.getImportMap(
+      this.state.data.genData!,
+    );
+    const rendered = getTaskTemplate(className, injectablesMap);
     const filename = `${utilService.titleizedToCase(targetName, convention)}${ProjectService.defaults.extention}`;
     const destination = path.join(targetDirectory, filename);
 
@@ -54,13 +63,13 @@ export default class GenerateTask extends GenAppTask {
 
   /**
    * Checks state for required fields. Executes prior to run method.
-   * Skips validation if genTargetType is not set to task.
+   * Skips validation if genData.targetType is not set to task.
    */
   async preRun() {
-    if (this.state.data.genTargetType !== GenTargetType.Task) {
+    if (this.state.data.genData!.targetType !== GenTargetType.Task) {
       return; // no validation on no-op flow
     }
-    if (!this.state.data.genTargetName) {
+    if (!this.state.data.genData!.targetName) {
       throw new Error("Unable to determine targetName");
     }
     if (!this.state.data.project) {

package/src/tasks/generate/project-context-guard.ts

@@ -4,7 +4,7 @@ import { AppTask } from "../../wrappers/app-task";
 import { autoInjectable } from "tsyringe";
 
 /**
- * Checks so see if we are in the context of a task-script-support
+ * Checks to see if we are in the context of a task-script-support
  * project or not and fails the process with a friendly error message.
  */
 @autoInjectable()

package/src/tasks/generate/resolve-injectables.ts

@@ -0,0 +1,154 @@
+import { AppTask } from "../../wrappers/app-task";
+import { autoInjectable } from "tsyringe";
+import { FileService } from "../../services/file-service";
+import { ProjectService } from "../../services/project-service";
+import { PromptService } from "../../services/prompt-service";
+import { UtilService } from "../../services/util-service";
+import { ProjectImport } from "../../types/project";
+import { CaseType } from "../../types/format";
+import { AppState, GenTargetType } from "../../types/state";
+
+/**
+ * ResolveInjectables
+ */
+@autoInjectable()
+export default class ResolveInjectables extends AppTask {
+  loggerName = "ResolveInjectables";
+
+  constructor(
+    private fileService: FileService,
+    private projectService: ProjectService,
+    private promptService: PromptService,
+    private utilService: UtilService,
+  ) {
+    super();
+  }
+
+  /**
+   * Prompts to select tasks or services to import into the file being generated.
+   *
+   * @param state the current state of the application. Expects genData to be
+   *  populated with targetType. Expects the project to be populated with
+   *  serviceDestination, taskDestination, and commandDestination.
+   * @returns updated state with genData imports field set.
+   */
+  async run(state: AppState): Promise<Partial<AppState>> {
+    if (this.shouldSkip()) return { data: { genData: { imports: [] } } };
+
+    const { genData, project } = state.data;
+
+    // determine the directory we would need to import into
+    const sourceDirectory =
+      genData!.targetType === GenTargetType.Service
+        ? project!.serviceDestination!
+        : project!.taskDestination!;
+
+    let injectableImports: ProjectImport[];
+    switch (genData!.targetType) {
+      case GenTargetType.Command:
+        injectableImports = await this.getTaskImports();
+        break;
+      case GenTargetType.Service:
+      case GenTargetType.Task:
+        injectableImports = await this.getServiceImports(sourceDirectory);
+        break;
+      default:
+        injectableImports = [];
+    }
+
+    return { data: { genData: { imports: injectableImports } } };
+  }
+
+  /**
+   * Prompt to select tasks to use in the command being generated.
+   *
+   * @returns the selected task imports
+   */
+  async getTaskImports(): Promise<ProjectImport[]> {
+    if (!this.state.data.project?.taskDestination) {
+      throw new Error("Unable to resolve task destination");
+    }
+
+    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`);
+    // add them to the map
+    return !pickedTasks.length
+      ? []
+      : this.projectService.formalizeImports(
+          pickedTasks,
+          this.state.data.project!.commandDestination!,
+        );
+  }
+
+  /**
+   * Prompt to select services to use in the command being generated.
+   *
+   * @param sourcePath the path to the parent directory of the source file being
+   *  generated to resolve relative paths for imports
+   * @returns the selected service imports
+   */
+  async getServiceImports(sourcePath: string): Promise<ProjectImport[]> {
+    if (!this.state.data.project?.serviceDestination) {
+      throw new Error("Unable to resolve service destination");
+    }
+
+    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`);
+
+    return !pickedServices.length
+      ? []
+      : this.projectService.formalizeImports(pickedServices, sourcePath);
+  }
+
+  /**
+   * 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,
+      })),
+    );
+  }
+
+  /**
+   * Determines if the task should skip the prompt for injectables.
+   *
+   * @returns true if the task should be skipped.
+   */
+  private shouldSkip(): boolean {
+    return (
+      !this.argService.hasFlag("inject") &&
+      this.state.data.genData?.targetType !== GenTargetType.Command
+    );
+  }
+}

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

@@ -25,7 +25,7 @@ export default class SelectGenTargetName extends AppTask {
     if (!targetName) {
       targetName =
         (await this.promptService.getInput(
-          `Enter Name for ${chalk.blueBright(this.utilService.titleize(this.state.data.genTargetType!))}`,
+          `Enter Name for ${chalk.blueBright(this.utilService.titleize(this.state.data.genData!.targetType!))}`,
         )) || ProjectService.defaults.targetName;
     }
     if (!targetName) {
@@ -33,12 +33,12 @@ export default class SelectGenTargetName extends AppTask {
     }
     this.logger.debug(`Name selected: ${chalk.magentaBright(targetName)}`);
     targetName = this.utilService.titleizeAll(targetName);
-    this.setData({ genTargetName: targetName });
+    this.setData({ genData: { targetName: targetName } });
   }
 
   async preRun() {
-    if (!this.state.data.genTargetType) {
-      throw new Error("Unable to determine genTargetType");
+    if (!this.state.data.genData?.targetType) {
+      throw new Error("Unable to determine genData.targetType");
     }
   }
 }

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

@@ -6,7 +6,7 @@ import { PromptService } from "../../services/prompt-service";
 import { CLIOptions } from "../../types/process";
 
 /**
- * Sets the genTargetType based on input
+ * Sets the genData.targetType based on input
  */
 @autoInjectable()
 export default class SelectGenTargetType extends AppTask {
@@ -31,7 +31,7 @@ export default class SelectGenTargetType extends AppTask {
     }
 
     this.logger.debug(`Target selected: ${chalk.magentaBright(target)}`);
-    this.setData({ genTargetType: target });
+    this.setData({ genData: { targetType: target } });
   }
 
   async getGenTargetInput() {

package/src/tasks/stdout/print-generated-results.ts

@@ -24,8 +24,8 @@ export default class PrintGeneratedResults extends AppTask {
   }
 
   async run() {
-    const genType: string = this.state.data.genTargetType
-      ? this.utilService.titleize(this.state.data.genTargetType)
+    const genType: string = this.state.data.genData?.targetType
+      ? this.utilService.titleize(this.state.data.genData.targetType)
       : "Project";
 
     this.logger.info(`Generated Results for ${chalk.blueBright(genType)}`);

package/src/tasks/sync-configuration.ts

@@ -39,15 +39,15 @@ export default class SyncConfiguration extends AppTask {
     }
 
     // get target destination if not cached yet
-    if (this.state.data.genTargetType) {
-      const targetType = this.state.data.genTargetType;
+    if (this.state.data.genData?.targetType) {
+      const targetType = this.state.data.genData.targetType;
       const destinationKey: keyof typeof project = `${targetType}Destination`;
       project[destinationKey] =
         project[destinationKey] || (await this.getDestination(targetType));
       this.logDestination(project[destinationKey]);
     }
 
-    // attempt to determine others config without prompting
+    // attempt to determine other config dirs without prompting
     const isPassive: boolean = true;
     project.commandDestination =
       project.commandDestination ||
@@ -75,7 +75,7 @@ export default class SyncConfiguration extends AppTask {
 
   /**
    * Gets the destination path for generating resources by resource type.
-   * If only one resource destination folder was found it is returned
+   * 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
@@ -121,9 +121,9 @@ export default class SyncConfiguration extends AppTask {
       );
     }
 
-    if (!this.state.data.genTargetType) {
+    if (!this.state.data.genData?.targetType) {
       throw new Error(
-        `Missing genTargetType! SyncConfiguration requires the SelectGenTarget task to be ran first.`,
+        `Missing genData.targetType! SyncConfiguration requires the SelectGenTarget task to be ran first.`,
       );
     }
   }

package/src/types/state.ts

@@ -1,6 +1,6 @@
 import { CLIArg } from "./process";
 import { AppState as State, TaskClass } from "task-script-support";
-import { ProjectConfig, ProjectData } from "./project";
+import { ProjectConfig, ProjectData, ProjectImport } from "./project";
 
 export enum GenTargetType {
   Command = "command",
@@ -8,12 +8,18 @@ export enum GenTargetType {
   Task = "task",
 }
 
+export interface GenData {
+  readonly targetType?: GenTargetType;
+  readonly targetName?: string;
+  readonly imports?: ProjectImport[];
+}
+
 export interface AppStateData {
   readonly banner?: {
     readonly font?: string;
   };
-  readonly genTargetType?: GenTargetType;
-  readonly genTargetName?: string;
+
+  readonly genData?: GenData;
 
   readonly environmentValidated?: boolean;
   readonly project?: ProjectConfig & ProjectData;

package/assets/yargs-template/task-runner/src/tasks/print-banner.ts

@@ -1,73 +0,0 @@
-import { autoInjectable } from "tsyringe";
-import { AppState } from "../types/state";
-import { AppTask } from "../wrappers/app-task";
-import { BannerService } from "../services/banner-service";
-import { UtilService } from "../services/util-service";
-import chalk from "chalk";
-
-/**
- * Prints an app banner to the console
- */
-@autoInjectable()
-export default class PrintBanner extends AppTask {
-  loggerName = "Print Banner";
-
-  constructor(
-    private bannnerSvc: BannerService,
-    private utilService: UtilService,
-  ) {
-    super();
-  }
-
-  async preRun() {
-    await this.validateFont();
-  }
-
-  async run({ args }: AppState): Promise<Partial<AppState> | void> {
-    let font = "";
-
-    try {
-      if (args.randomFont) {
-        font = await this.bannnerSvc.getRandomFont();
-        console.log(`Using random font ${font}`);
-      }
-
-      // allow banner-font as user input
-      if (args.bannerFont) {
-        font = args.bannerFont;
-      }
-
-      console.log(
-        chalk.blueBright(
-          await this.bannnerSvc.toBanner(this.utilService.getAppName(), font),
-        ),
-      );
-
-      // mutate state
-      this.setData({
-        banner: { font: font || this.bannnerSvc.defaultFontFamily },
-      });
-
-      // return updated state instead of calling setData
-      return { data: { banner: { status: "success" } } } as const;
-    } catch (err) {
-      this.setData({ banner: { status: "failed" }, errorMessages: [`${err}`] });
-    }
-  }
-
-  /*
-    Helper for ensuring font is supported if provided as input
-  */
-  async validateFont() {
-    const { args } = this.state;
-    if (!args.bannerFont) {
-      return;
-    }
-
-    const fontName = args.bannerFont;
-    const availableFonts = await this.bannnerSvc.getSupportedFonts();
-    if (!availableFonts.includes(fontName)) {
-      throw new Error(`Unsupported font provided: ${chalk.red(fontName)}`);
-    }
-  }
-}