task-script-support-cli 0.1.1

package/src/tasks/generate-task.ts

@@ -0,0 +1,83 @@
+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";
+
+/**
+ * Generates a new task class
+ */
+@autoInjectable()
+export default class GenerateTask extends AppTask {
+  loggerName = "Generate Task";
+
+  constructor(
+    private utilService: UtilService,
+    private fileService: FileService,
+    private projectService: ProjectService,
+  ) {
+    super();
+  }
+
+  async run() {
+    if (this.state.data.genTargetType !== GenTargetType.Task) {
+      return;
+    }
+
+    const { utilService, argService } = this;
+
+    this.logger.info(chalk.blueBright("Generating Task"));
+
+    let targetName = argService.getTargetName();
+    if (!targetName) {
+      // TODO: Prompt for target name?
+      targetName = argService.cleanTargetName(
+        ProjectService.defaults.targetName,
+      );
+    }
+
+    const targetDirectory = this.getTargetDirectory();
+    if (!targetDirectory) {
+      throw new Error("Unable to determine target Directory");
+    }
+
+    // detect case
+    const convention = this.projectService.getConvention();
+    this.logger.debug(`Using convention: ${chalk.magentaBright(convention)}`);
+    const className = utilService.titleizedToCase(
+      targetName,
+      CaseType.PASCAL_CASE,
+    );
+
+    const rendered = getTaskTemplate(className);
+    const filename = `${utilService.titleizedToCase(targetName, convention)}${ProjectService.defaults.extention}`;
+    const destination = path.join(targetDirectory, filename);
+
+    // write contents
+    this.fileService.writeFile(destination, rendered);
+    return { data: { outputDestination: destination } };
+  }
+
+  /**
+   * Get the target directory to save the generated file.
+   *
+   * @returns the destination path of the parent folder to save the new file in.
+   */
+  getTargetDirectory() {
+    const runnerRoot = this.fileService.getRunnerRootDir();
+    const tasksFolders = this.fileService.getTaskDirs(runnerRoot);
+
+    if (tasksFolders.length === 1) {
+      return tasksFolders[0];
+    }
+
+    // TODO: prompt to select destination from available tasksFolders
+    this.logger.warn(`Multiple task folders detected. Using first found.`);
+    return tasksFolders[0];
+  }
+}

package/src/tasks/print-about-information.ts

@@ -0,0 +1,16 @@
+import chalk from "chalk";
+import { UtilService } from "../services/util-service";
+import { AppTask } from "../wrappers/app-task";
+import { autoInjectable } from "tsyringe";
+
+/**
+ * Prints general information about the app
+ */
+@autoInjectable()
+export default class PrintAboutInformation extends AppTask {
+  async run() {
+    console.log(`Name:    ${chalk.green("Task Script Support CLI")}`);
+    console.log(`Version: ${chalk.green(UtilService.getAppVersion())}`);
+    console.log(`About:   ${chalk.dim(UtilService.getAppDescription())}`);
+  }
+}

package/src/tasks/print-banner.ts

@@ -0,0 +1,37 @@
+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";
+
+@autoInjectable()
+export default class PrintBanner extends AppTask {
+  loggerName = "Print Banner";
+
+  constructor(
+    private bannnerSvc: BannerService,
+    private utilSvc: UtilService,
+  ) {
+    super();
+  }
+
+  async run(): Promise<Partial<AppState> | void> {
+    let font = "";
+
+    if (this.argService.hasFlag("randomFont")) {
+      font = await this.bannnerSvc.getRandomFont();
+      console.log(`Using random font ${font}`);
+    }
+
+    console.log(
+      chalk.blueBright(
+        await this.bannnerSvc.toBanner(this.utilSvc.getAppName(), font),
+      ),
+    );
+
+    this.setData({
+      banner: { font: font || this.bannnerSvc.defaultFontFamily },
+    });
+  }
+}

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

@@ -0,0 +1,36 @@
+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";
+
+/**
+ * Prints the generated output results
+ */
+@autoInjectable()
+export default class PrintGeneratedResults extends AppTask {
+  loggerName = "Print Results";
+
+  constructor(private utilService: UtilService) {
+    super();
+  }
+
+  async run() {
+    const target: GenTargetType = this.state.data.genTargetType!;
+    this.logger.info(
+      chalk.blueBright(
+        `Generated Results for ${this.utilService.titleize(target)}`,
+      ),
+    );
+
+    setTimeout(() => {
+      console.log(`
+        
+        Generated new file:
+
+          ${this.state.data.outputDestination || "<None>"}
+        
+        `);
+    }, 1000);
+  }
+}

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

@@ -0,0 +1,29 @@
+import chalk from "chalk";
+import { AppTask } from "../wrappers/app-task";
+import { autoInjectable } from "tsyringe";
+import { GenTargetType } from "../types/state";
+
+/**
+ * Sets the genTargetType based on input
+ */
+@autoInjectable()
+export default class SelectGenTarget extends AppTask {
+  loggerName = "Select Target";
+  async run() {
+    let target: GenTargetType = GenTargetType.Command;
+    this.logger.info(chalk.blueBright("Checking Target"));
+
+    if (this.argService.hasFlag("service")) {
+      target = GenTargetType.Service;
+    } else if (this.argService.hasFlag("task")) {
+      target = GenTargetType.Task;
+    } else if (this.argService.hasFlag("command")) {
+      target = GenTargetType.Command;
+    } else {
+      this.logger.warn(`Using default target: ${target}`);
+    }
+
+    this.logger.debug(`Target selected: ${chalk.magentaBright(target)}`);
+    this.setData({ genTargetType: target });
+  }
+}

package/src/templates/command.ts

@@ -0,0 +1,18 @@
+export const getCommandTemplate = (
+  className: string,
+  tasks: Map<string, string> = new Map(),
+) =>
+  `import { singleton } from "tsyringe";
+import { Command } from "../wrappers/command";
+${tasks
+  .keys()
+  .toArray()
+  .map((k) => `import { ${k} } from "${tasks.get(k)}";`)
+  .join("\n")}
+
+@singleton()
+export class ${className} extends Command {
+  tasks = [${tasks.keys().toArray().join(",")}];
+}
+
+`;

package/src/templates/service.ts

@@ -0,0 +1,12 @@
+export const getServiceTemplate = (className: string) =>
+  `import { singleton } from "tsyringe";
+
+/**
+ * ${className}
+ */
+@singleton()
+export default class ${className} {
+  constructor() {}
+}
+
+`;

package/src/templates/task.ts

@@ -0,0 +1,16 @@
+export const getTaskTemplate = (className: string) =>
+  `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
+  }
+}
+
+`;

package/src/types/format.ts

@@ -0,0 +1,6 @@
+export enum CaseType {
+  KEBAB_CASE = "kebab-case",
+  SNAKE_CASE = "snake_case",
+  CAMEL_CASE = "camelCase",
+  PASCAL_CASE = "pascalCase",
+}

package/src/types/process.ts

@@ -0,0 +1,18 @@
+export interface ProcessStatus {
+  readonly pid: number;
+  readonly status: "running" | "completed" | "unknown";
+}
+
+export interface ArgObject {
+  readonly [name: string]: string | boolean | number;
+}
+
+export type CLIArg = string | string[] | ArgObject;
+
+export enum CLIOptions {
+  randomFont = "randomFont",
+  service = "service",
+  command = "command",
+  task = "task",
+  targetName = "targetName",
+}

package/src/types/state.ts

@@ -0,0 +1,29 @@
+import { CLIArg } from "./process";
+import { AppState as State, TaskClass } from "task-script-support";
+
+export enum GenTargetType {
+  Command = "command",
+  Service = "service",
+  Task = "task",
+}
+
+export interface AppStateData {
+  readonly errorMessages?: string[];
+  readonly banner?: {
+    readonly font?: string;
+  };
+  readonly genTargetType?: GenTargetType;
+  readonly environmentValidated?: boolean;
+  readonly outputDestination?: string;
+}
+
+export const EnvironmentConfigKeys = {
+  PINO_LOG_DIR_PATH: "PINO_LOG_DIR_PATH",
+  PINO_LOG_LEVEL: "PINO_LOG_LEVEL",
+  NODE_ENV: "NODE_ENV",
+  PINO_LOG_FILENAME: "PINO_LOG_FILENAME",
+  PINO_LOG_TARGET: "PINO_LOG_TARGET",
+};
+
+export type AppState = State<AppStateData, CLIArg[]>;
+export type AppTaskClass = TaskClass<AppStateData, CLIArg[]>;

package/src/wrappers/app-task.ts

@@ -0,0 +1,48 @@
+import { autoInjectable } from "tsyringe";
+import { CommandService, Task } from "task-script-support";
+import { LogService } from "../services/log-service";
+import { ArgService } from "../services/arg-service";
+import type { AppState, AppStateData } from "../types/state";
+import type { CLIArg } from "../types/process";
+
+@autoInjectable()
+export class AppTask extends Task<AppStateData, CLIArg[]> {
+  state: AppState = {
+    id: "uninitialized",
+    args: [],
+    data: {},
+  };
+  loggerName: string = "";
+
+  get argService() {
+    return this._argService!;
+  }
+  get logger(): LogService {
+    return this._logService!;
+  }
+
+  constructor(
+    public _logService?: LogService,
+    public _argService?: ArgService,
+    public _commandService?: CommandService<AppStateData, CLIArg[]>,
+  ) {
+    super();
+  }
+
+  //@override
+  async initialize() {
+    if (this.loggerName) {
+      this.logger!.setPrefix(`${this.loggerName} :: `);
+    }
+  }
+
+  //@override
+  async run(state: AppState): Promise<Partial<AppState> | void> {
+    throw new Error(`run not implemented (${state.id})`);
+  }
+
+  setData(data: Partial<AppStateData>) {
+    this.state = this._commandService!.setData(this.state, data);
+    return this.state;
+  }
+}

package/src/wrappers/command.ts

@@ -0,0 +1,21 @@
+import { CommandService } from "task-script-support";
+import { inject } from "tsyringe";
+import { AppStateData, AppTaskClass } from "../types/state";
+import { CLIArg } from "../types/process";
+
+export class Command {
+  tasks: (AppTaskClass | AppTaskClass[])[] = [];
+
+  constructor(
+    @inject(CommandService<AppStateData, CLIArg[]>)
+    private commandService: CommandService<AppStateData, CLIArg[]>,
+  ) {}
+
+  get handler(): (cliArgs: unknown[]) => Promise<void> {
+    return this.commandService.fromTasks(this.getTasks());
+  }
+
+  getTasks(): (AppTaskClass | AppTaskClass[])[] {
+    return this.tasks;
+  }
+}

package/tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    "rootDir": ".",
+    "sourceRoot": "./src",
+    "outDir": "./dist",
+    "module": "node16",
+    "target": "esnext",
+    "lib": ["esnext"],
+    "types": ["node", "vitest"],
+    "sourceMap": true,
+    "declaration": true,
+    "declarationMap": true,
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+    "strict": true,
+    "jsx": "react-jsx",
+    "resolveJsonModule": true,
+    "esModuleInterop": true,
+    "isolatedModules": true,
+    "noUncheckedSideEffectImports": true,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "moduleDetection": "force",
+    "skipLibCheck": true
+  },
+  "exclude": ["node_modules", "dist", "tests"]
+}

package/tssc

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+require("./src/index.js");