task-script-support-cli 0.2.20 → 0.3.0

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,
+      })),
+    );
+  }
+}