task-script-support-cli 0.2.20 → 0.3.2

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

@@ -1,13 +1,13 @@
 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 { AppTask } from "../../wrappers/app-task";
+import { FileService } from "../../services/file-service";
+import { UtilService } from "../../services/util-service";
 
 /**
  * Generates a new task class
@@ -17,9 +17,9 @@ export default class GenerateTask extends AppTask {
   loggerName = "Generate Task";
 
   constructor(
-    private utilService: UtilService,
     private fileService: FileService,
     private projectService: ProjectService,
+    private utilService: UtilService,
   ) {
     super();
   }
@@ -27,10 +27,10 @@ export default class GenerateTask extends AppTask {
   /**
    * 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) {
+    if (this.state.data.genData!.targetType !== GenTargetType.Task) {
       return;
     }
 
@@ -38,7 +38,7 @@ export default class GenerateTask extends AppTask {
 
     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
@@ -49,7 +49,10 @@ export default class GenerateTask extends AppTask {
       CaseType.PASCAL_CASE,
     );
 
-    const rendered = getTaskTemplate(className);
+    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);
 
@@ -60,13 +63,13 @@ export default class GenerateTask extends AppTask {
 
   /**
    * 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/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/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)}`);
-    }
-  }
-}

package/dist/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)}`);
-    }
-  }
-}