task-script-support-cli 0.1.1 → 0.2.3

package/src/tasks/print-banner.ts

@@ -1,5 +1,5 @@
 import { autoInjectable } from "tsyringe";
-import { AppState } from "../types/state";
+import { AppState, EnvironmentConfigKeys } from "../types/state";
 import { AppTask } from "../wrappers/app-task";
 import { BannerService } from "../services/banner-service";
 import { UtilService } from "../services/util-service";
@@ -10,8 +10,8 @@ export default class PrintBanner extends AppTask {
   loggerName = "Print Banner";
 
   constructor(
-    private bannnerSvc: BannerService,
-    private utilSvc: UtilService,
+    private bannnerService: BannerService,
+    private utilService: UtilService,
   ) {
     super();
   }
@@ -19,19 +19,23 @@ export default class PrintBanner extends AppTask {
   async run(): Promise<Partial<AppState> | void> {
     let font = "";
 
+    if (process.env[EnvironmentConfigKeys.TSSC_SILENCE_BANNER]) {
+      return;
+    }
+
     if (this.argService.hasFlag("randomFont")) {
-      font = await this.bannnerSvc.getRandomFont();
+      font = await this.bannnerService.getRandomFont();
       console.log(`Using random font ${font}`);
     }
 
     console.log(
       chalk.blueBright(
-        await this.bannnerSvc.toBanner(this.utilSvc.getAppName(), font),
+        await this.bannnerService.toBanner(this.utilService.getAppName(), font),
       ),
     );
 
     this.setData({
-      banner: { font: font || this.bannnerSvc.defaultFontFamily },
+      banner: { font: font || this.bannnerService.defaultFontFamily },
     });
   }
 }

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

@@ -1,8 +1,8 @@
 import chalk from "chalk";
 import { AppTask } from "../wrappers/app-task";
 import { autoInjectable } from "tsyringe";
-import { GenTargetType } from "../types/state";
 import { UtilService } from "../services/util-service";
+import { ProjectService } from "../services/project-service";
 
 /**
  * Prints the generated output results
@@ -16,21 +16,21 @@ export default class PrintGeneratedResults extends AppTask {
   }
 
   async run() {
-    const target: GenTargetType = this.state.data.genTargetType!;
-    this.logger.info(
-      chalk.blueBright(
-        `Generated Results for ${this.utilService.titleize(target)}`,
-      ),
-    );
+    const genType: string = this.state.data.genTargetType
+      ? this.utilService.titleize(this.state.data.genTargetType)
+      : "Project";
 
-    setTimeout(() => {
-      console.log(`
-        
-        Generated new file:
+    this.logger.info(`Generated Results for ${chalk.blueBright(genType)}`);
 
-          ${this.state.data.outputDestination || "<None>"}
-        
-        `);
-    }, 1000);
+    // wait for logs to flush before mixing in console.log
+    await this.utilService.sleep(200);
+
+    console.log(`
+      
+      Generated new ${this.state.data.outputDestination?.includes(ProjectService.defaults.extention) ? "file" : "project"}:
+
+        ${this.state.data.outputDestination || "<None>"}
+      
+      `);
   }
 }

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

@@ -0,0 +1,44 @@
+import chalk from "chalk";
+import { AppTask } from "../wrappers/app-task";
+import { autoInjectable } from "tsyringe";
+import { PromptService } from "../services/prompt-service";
+import { ProjectService } from "../services/project-service";
+import { UtilService } from "../services/util-service";
+
+/**
+ * SelectGenTargetName
+ */
+@autoInjectable()
+export default class SelectGenTargetName extends AppTask {
+  loggerName = "SelectGenTargetName";
+  constructor(
+    private promptService: PromptService,
+    private utilService: UtilService,
+  ) {
+    super();
+  }
+
+  async run() {
+    this.logger.info(chalk.blueBright("Checking Target Name"));
+
+    let targetName = this.argService.getTargetName();
+    if (!targetName) {
+      targetName =
+        (await this.promptService.getInput(
+          `Enter Name for ${chalk.blueBright(this.utilService.titleize(this.state.data.genTargetType!))}`,
+        )) || ProjectService.defaults.targetName;
+    }
+    if (!targetName) {
+      throw new Error("Unable to resolve targetName");
+    }
+
+    this.logger.debug(`Target selected: ${chalk.magentaBright(targetName)}`);
+    this.setData({ genTargetName: targetName });
+  }
+
+  async preRun() {
+    if (!this.state.data.genTargetType) {
+      throw new Error("Unable to determine genTargetType");
+    }
+  }
+}

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

@@ -2,6 +2,7 @@ import chalk from "chalk";
 import { AppTask } from "../wrappers/app-task";
 import { autoInjectable } from "tsyringe";
 import { GenTargetType } from "../types/state";
+import { PromptService } from "../services/prompt-service";
 
 /**
  * Sets the genTargetType based on input
@@ -9,6 +10,11 @@ import { GenTargetType } from "../types/state";
 @autoInjectable()
 export default class SelectGenTarget extends AppTask {
   loggerName = "Select Target";
+
+  constructor(private promptService: PromptService) {
+    super();
+  }
+
   async run() {
     let target: GenTargetType = GenTargetType.Command;
     this.logger.info(chalk.blueBright("Checking Target"));
@@ -20,10 +26,19 @@ export default class SelectGenTarget extends AppTask {
     } else if (this.argService.hasFlag("command")) {
       target = GenTargetType.Command;
     } else {
-      this.logger.warn(`Using default target: ${target}`);
+      target = await this.getGenTargetInput();
     }
 
     this.logger.debug(`Target selected: ${chalk.magentaBright(target)}`);
     this.setData({ genTargetType: target });
   }
+
+  async getGenTargetInput() {
+    const targetType: GenTargetType = await this.promptService.select(
+      `Select a type of ${chalk.blueBright("Resource")} to create`,
+      [GenTargetType.Command, GenTargetType.Service, GenTargetType.Task],
+    );
+
+    return targetType;
+  }
 }

package/src/tasks/sync-configuration.ts

@@ -0,0 +1,121 @@
+import { autoInjectable } from "tsyringe";
+import { AppTask } from "../wrappers/app-task";
+import { PromptService } from "../services/prompt-service";
+import chalk from "chalk";
+import { CacheService } from "../services/cache-service";
+import { ProjectConfig, ProjectData } from "../types/project";
+import { GenTargetType } from "../types/state";
+import { UtilService } from "../services/util-service";
+
+@autoInjectable()
+export class SyncConfiguration extends AppTask {
+  loggerName = "Sync Configuration";
+
+  constructor(
+    private promptService: PromptService,
+    private cacheService: CacheService,
+    private utilService: UtilService,
+  ) {
+    super();
+  }
+
+  async preRun() {
+    this.verifyState();
+  }
+
+  async run() {
+    this.logger.info(chalk.blueBright("Checking Cache"));
+    let project: ProjectConfig & ProjectData = this.state.data.project!;
+
+    // see if we have a project config in the cache with rootDir path as the key
+    const cachedProject = await this.cacheService.getProject(project.rootDir);
+    if (cachedProject) {
+      this.logger.debug(chalk.dim("loaded project from cache"));
+      project = { ...this.state.data.project!, ...cachedProject };
+    }
+
+    // get target destination if not cached yet
+    switch (this.state.data.genTargetType) {
+      case GenTargetType.Command:
+        project.commandDestination =
+          project.commandDestination || (await this.getDestination("command"));
+
+        this.logDestination(project.commandDestination);
+        break;
+      case GenTargetType.Service:
+        project.serviceDestination =
+          project.serviceDestination || (await this.getDestination("service"));
+
+        this.logDestination(project.serviceDestination);
+        break;
+      case GenTargetType.Task:
+        project.taskDestination =
+          project.taskDestination || (await this.getDestination("task"));
+
+        this.logDestination(project.taskDestination);
+        break;
+      default:
+        throw new Error(`Uknown target type: ${this.state.data.genTargetType}`);
+    }
+
+    // cache any changes
+    await this.cacheService.writeProject(project);
+    this.setData({ project });
+  }
+
+  /**
+   * Prints the target destination path string
+   *
+   * @param dest the destination path to log
+   * @returns
+   */
+  logDestination = (dest: string = "") =>
+    this.logger.debug(`Destination: ${chalk.magentaBright(dest)}`);
+
+  /**
+   * Gets the destination path for generating resources by resource type.
+   * 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
+   * @returns the path of the resolved destination
+   */
+  async getDestination(keyType: "command" | "task" | "service") {
+    const foldersKey: keyof typeof this.state.data.project =
+      `${keyType}Folders` as keyof typeof this.state.data.project;
+
+    const nonTestFolders: string[] = (
+      this.state.data.project![foldersKey] as string[]
+    ).filter((folder: string) => !(folder || "").includes("/tests/"));
+
+    // if we only have one folder found, use this as the destination
+    if (nonTestFolders.length === 1) {
+      return nonTestFolders[0] || "";
+    }
+
+    // otherwise prompt to pick one
+    const userSelection: string = await this.promptService.select(
+      `Multiple folders found. Select correct ${chalk.blueBright(this.utilService.titleize(keyType))} folder`,
+      nonTestFolders,
+    );
+    this.logger.debug(chalk.blackBright(`caching for next time`));
+    return userSelection;
+  }
+
+  /**
+   * Check we have all the required state set
+   */
+  verifyState() {
+    if (!this.state.data.project || !this.state.data.project.rootDir) {
+      throw new Error(
+        `Missing project rootDir! SyncConfiguration requires the CheckEnvironment task to be ran first.`,
+      );
+    }
+
+    if (!this.state.data.genTargetType) {
+      throw new Error(
+        `Missing genTargetType! SyncConfiguration requires the SelectGenTarget task to be ran first.`,
+      );
+    }
+  }
+}

package/src/tasks/test-task.ts

@@ -0,0 +1,20 @@
+import { autoInjectable } from "tsyringe";
+import { AppState } from "../types/state";
+import { AppTask } from "../wrappers/app-task";
+import chalk from "chalk";
+import { PromptService } from "../services/prompt-service";
+
+@autoInjectable()
+export default class TestTask extends AppTask {
+  loggerName = "Testing Things";
+
+  constructor(private promptService: PromptService) {
+    super();
+  }
+
+  async run(): Promise<Partial<AppState> | void> {
+    // test task
+
+    console.log(chalk.magentaBright(JSON.stringify(this.state)));
+  }
+}

package/src/templates/command.ts

@@ -7,12 +7,12 @@ import { Command } from "../wrappers/command";
 ${tasks
   .keys()
   .toArray()
-  .map((k) => `import { ${k} } from "${tasks.get(k)}";`)
+  .map((k) => `import ${k} from "${tasks.get(k)}";`)
   .join("\n")}
 
 @singleton()
 export class ${className} extends Command {
-  tasks = [${tasks.keys().toArray().join(",")}];
+  tasks = [${tasks.keys().toArray().join(", ")}];
 }
 
 `;

package/src/templates/service.ts

@@ -5,7 +5,7 @@ export const getServiceTemplate = (className: string) =>
  * ${className}
  */
 @singleton()
-export default class ${className} {
+export class ${className} {
   constructor() {}
 }
 

package/src/types/process.ts

@@ -15,4 +15,5 @@ export enum CLIOptions {
   command = "command",
   task = "task",
   targetName = "targetName",
+  name = "name",
 }

package/src/types/project.ts

@@ -0,0 +1,12 @@
+export interface ProjectConfig {
+  rootDir: string;
+  taskDestination?: string | undefined;
+  serviceDestination?: string | undefined;
+  commandDestination?: string | undefined;
+}
+
+export interface ProjectData {
+  taskFolders: string[];
+  serviceFolders: string[];
+  commandFolders: string[];
+}

package/src/types/state.ts

@@ -1,5 +1,6 @@
 import { CLIArg } from "./process";
 import { AppState as State, TaskClass } from "task-script-support";
+import { ProjectConfig, ProjectData } from "./project";
 
 export enum GenTargetType {
   Command = "command",
@@ -8,12 +9,16 @@ export enum GenTargetType {
 }
 
 export interface AppStateData {
-  readonly errorMessages?: string[];
   readonly banner?: {
     readonly font?: string;
   };
   readonly genTargetType?: GenTargetType;
+  readonly genTargetName?: string;
+
   readonly environmentValidated?: boolean;
+  readonly project?: ProjectConfig & ProjectData;
+
+  readonly errorMessages?: string[];
   readonly outputDestination?: string;
 }
 
@@ -23,6 +28,7 @@ export const EnvironmentConfigKeys = {
   NODE_ENV: "NODE_ENV",
   PINO_LOG_FILENAME: "PINO_LOG_FILENAME",
   PINO_LOG_TARGET: "PINO_LOG_TARGET",
+  TSSC_SILENCE_BANNER: "TSSC_SILENCE_BANNER",
 };
 
 export type AppState = State<AppStateData, CLIArg[]>;

package/tests/index.spec.ts

@@ -0,0 +1,8 @@
+import { describe, it, expect } from "vitest";
+
+describe("index", () => {
+  it("should ...", () => {
+    // TODO: add tests
+    expect(1).toBeTruthy();
+  });
+});

package/tests/setup.ts

@@ -0,0 +1 @@
+import "reflect-metadata";

package/tsconfig.json

@@ -23,5 +23,5 @@
     "moduleDetection": "force",
     "skipLibCheck": true
   },
-  "exclude": ["node_modules", "dist", "tests"]
+  "exclude": ["node_modules", "dist", "tests", "assets"]
 }

package/vitest.config.ts

@@ -0,0 +1,14 @@
+const { defineConfig, configDefaults } = require("vitest/config");
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: "node",
+    setupFiles: "./tests/setup.ts",
+    exclude: [...configDefaults.exclude, "assets/**/*", "dist/**/*"],
+    coverage: {
+      provider: "v8",
+      reporter: ["text", "json", "html"],
+    },
+  },
+});