@tsed/cli-tasks 7.0.0-beta.13

package/src/domain/TaskLogger.spec.ts

@@ -0,0 +1,324 @@
+import {contextLogger, DITest, runInContext} from "@tsed/di";
+import type {MockInstance} from "vitest";
+import {afterEach, beforeAll, beforeEach, describe, expect, it, vi} from "vitest";
+
+import type {TaskLogger as TaskLoggerClass} from "./TaskLogger.js";
+
+type ProgressStub = {
+  start: ReturnType<typeof vi.fn>;
+  stop: ReturnType<typeof vi.fn>;
+  advance: ReturnType<typeof vi.fn>;
+};
+
+type SpinnerStub = {
+  start: ReturnType<typeof vi.fn>;
+  stop: ReturnType<typeof vi.fn>;
+  message: ReturnType<typeof vi.fn>;
+};
+
+type TaskLogStub = {
+  title: string;
+  info: ReturnType<typeof vi.fn>;
+  warn: ReturnType<typeof vi.fn>;
+  error: ReturnType<typeof vi.fn>;
+  message: ReturnType<typeof vi.fn>;
+  success: ReturnType<typeof vi.fn>;
+  group: ReturnType<typeof vi.fn>;
+};
+
+type LogMock = {
+  info: ReturnType<typeof vi.fn>;
+  warn: ReturnType<typeof vi.fn>;
+  error: ReturnType<typeof vi.fn>;
+  message: ReturnType<typeof vi.fn>;
+  success: ReturnType<typeof vi.fn>;
+};
+
+type ClackMocks = {
+  logMock: LogMock;
+  progressInstances: ProgressStub[];
+  spinnerInstances: SpinnerStub[];
+  taskLogInstances: TaskLogStub[];
+  progressMock: ReturnType<typeof vi.fn>;
+  spinnerMock: ReturnType<typeof vi.fn>;
+  taskLogMock: ReturnType<typeof vi.fn>;
+};
+
+const clack = vi.hoisted(() => {
+  const logMock: LogMock = {
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    message: vi.fn(),
+    success: vi.fn()
+  };
+
+  const progressInstances: ProgressStub[] = [];
+  const spinnerInstances: SpinnerStub[] = [];
+  const taskLogInstances: TaskLogStub[] = [];
+
+  const createProgressInstance = () => {
+    const instance: ProgressStub = {
+      start: vi.fn(),
+      stop: vi.fn(),
+      advance: vi.fn()
+    };
+
+    progressInstances.push(instance);
+    return instance;
+  };
+
+  const createSpinnerInstance = () => {
+    const instance: SpinnerStub = {
+      start: vi.fn(),
+      stop: vi.fn(),
+      message: vi.fn()
+    };
+
+    spinnerInstances.push(instance);
+    return instance;
+  };
+
+  const createTaskLogInstance = (title: string): TaskLogStub => {
+    const instance: TaskLogStub = {
+      title,
+      info: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+      message: vi.fn(),
+      success: vi.fn(),
+      group: vi.fn()
+    };
+
+    instance.group.mockImplementation((childTitle: string) => createTaskLogInstance(childTitle));
+    taskLogInstances.push(instance);
+
+    return instance;
+  };
+
+  return {
+    logMock,
+    progressInstances,
+    spinnerInstances,
+    taskLogInstances,
+    progressMock: vi.fn(() => createProgressInstance()),
+    spinnerMock: vi.fn(() => createSpinnerInstance()),
+    taskLogMock: vi.fn(({title}: {title: string}) => createTaskLogInstance(title))
+  };
+}) as ClackMocks;
+
+vi.mock("@clack/prompts", () => ({
+  log: clack.logMock,
+  progress: clack.progressMock,
+  spinner: clack.spinnerMock,
+  taskLog: clack.taskLogMock
+}));
+
+const {logMock, progressInstances, spinnerInstances, taskLogInstances} = clack;
+const originalNodeEnv = process.env.NODE_ENV;
+
+describe("TaskLogger", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    progressInstances.length = 0;
+    spinnerInstances.length = 0;
+    taskLogInstances.length = 0;
+    process.env.NODE_ENV = "development";
+
+    return DITest.create({
+      env: "test"
+    });
+  });
+
+  afterEach(() => {
+    process.env.NODE_ENV = originalNodeEnv;
+    return DITest.reset();
+  });
+
+  it("logs start/done using the default log prompt", () => {
+    const logger = TaskLogger.from({
+      title: "Build project",
+      index: 0
+    });
+
+    expect(logger.type).toBe("log");
+
+    logger.start();
+    logger.done();
+
+    expect(logMock.info).toHaveBeenCalledWith("Build project...");
+    expect(logMock.success).toHaveBeenCalledWith("Build project completed");
+  });
+
+  it("emits message when the title changes", () => {
+    const logger = TaskLogger.from({
+      title: "Initial",
+      index: 0
+    });
+
+    logger.title = "Updated title";
+
+    expect(logMock.message).toHaveBeenCalledWith("Updated title");
+  });
+
+  it("advances the parent progress bar for child progress tasks", () => {
+    const parent = new TaskLogger({
+      title: "Install dependencies",
+      index: 0,
+      type: "progress"
+    });
+    parent.max = 4;
+
+    const child = TaskLogger.from({
+      title: "Install packages",
+      index: 1,
+      parent
+    });
+
+    child.start();
+
+    expect(progressInstances[0]?.advance).toHaveBeenCalledWith(25, "Install packages");
+  });
+
+  it("returns the spinner parent when nested spinner tasks are requested", () => {
+    const spinnerParent = new TaskLogger({
+      title: "Loading spinner",
+      index: 0,
+      type: "spinner"
+    });
+
+    const nested = TaskLogger.from({
+      title: "Nested spinner",
+      index: 1,
+      parent: spinnerParent
+    });
+
+    expect(nested).toBe(spinnerParent);
+  });
+
+  it("marks taskLog children as skipped via error logger", () => {
+    const parent = new TaskLogger({
+      title: "Parent log",
+      index: 0,
+      type: "taskLog"
+    });
+
+    const child = TaskLogger.from({
+      title: "Child log",
+      index: 1,
+      parent
+    });
+
+    child.skip();
+
+    const childLogger = taskLogInstances.find((instance) => instance.title === "Child log");
+    expect(childLogger?.error).toHaveBeenCalledWith("Child log skipped...");
+  });
+
+  it("creates grouped loggers for nested taskLog hierarchies", () => {
+    const root = new TaskLogger({
+      title: "Root task",
+      index: 0,
+      type: "taskLog"
+    });
+    const child = TaskLogger.from({
+      title: "Child task",
+      index: 1,
+      parent: root
+    });
+
+    TaskLogger.from({
+      title: "Grandchild task",
+      index: 2,
+      parent: child
+    });
+
+    const childLogger = taskLogInstances.find((instance) => instance.title === "Child task");
+    const grandChildLogger = taskLogInstances.find((instance) => instance.title === "Grandchild task");
+
+    expect(childLogger?.group).toHaveBeenCalledWith("Grandchild task");
+    expect(grandChildLogger).toBeDefined();
+  });
+
+  it("routes verbose output through the context logger", async () => {
+    const ctx = DITest.createDIContext();
+    let infoSpy!: MockInstance;
+    let warnSpy!: MockInstance;
+    let errorSpy!: MockInstance;
+
+    await runInContext(ctx, () => {
+      const scopedLogger = contextLogger();
+      infoSpy = vi.spyOn(scopedLogger, "info");
+      warnSpy = vi.spyOn(scopedLogger, "warn");
+      errorSpy = vi.spyOn(scopedLogger, "error");
+
+      const logger = new TaskLogger({
+        title: "Verbose task",
+        index: 0,
+        type: "log",
+        verbose: true
+      });
+
+      logger.message("hello");
+      logger.warn("be careful");
+      logger.error("boom");
+      logger.report("report payload");
+
+      return logger;
+    });
+
+    expect(infoSpy).toHaveBeenCalledWith({
+      state: "MSG",
+      title: "Verbose task",
+      message: "Verbose task - hello"
+    });
+    expect(warnSpy).toHaveBeenCalledWith({
+      title: "Verbose task",
+      message: "Verbose task - be careful"
+    });
+    expect(errorSpy).toHaveBeenCalledWith({
+      title: "Verbose task",
+      message: "Verbose task - boom"
+    });
+    expect(infoSpy).toHaveBeenCalledWith({
+      title: "Verbose task",
+      message: "report payload"
+    });
+  });
+
+  it("does not emit context logger output when NODE_ENV=test", async () => {
+    process.env.NODE_ENV = "test";
+    const ctx = DITest.createDIContext();
+
+    await runInContext(ctx, () => {
+      const scopedLogger = contextLogger();
+      const infoSpy = vi.spyOn(scopedLogger, "info");
+
+      const logger = new TaskLogger({
+        title: "Suppressed task",
+        index: 0,
+        type: "log",
+        verbose: true
+      });
+
+      logger.message("should not show");
+      expect(infoSpy).not.toHaveBeenCalled();
+    });
+  });
+
+  it("writes raw output through info fallback", () => {
+    const logger = TaskLogger.from({
+      title: "Output task",
+      index: 0
+    });
+
+    logger.output = "custom message";
+
+    expect(logMock.info).toHaveBeenCalledWith("custom message");
+  });
+});
+let TaskLogger: typeof TaskLoggerClass;
+
+beforeAll(async () => {
+  ({TaskLogger} = await import("./TaskLogger.js"));
+});

package/src/domain/TaskLogger.ts

@@ -0,0 +1,319 @@
+import {log, progress, spinner, taskLog} from "@clack/prompts";
+import {contextLogger} from "@tsed/di";
+
+export interface TaskLoggerOptions {
+  title: string;
+  index: number;
+  type?: "group" | "taskLog" | "log" | "spinner" | "progress";
+  parent?: TaskLogger;
+  verbose?: boolean;
+}
+
+export class TaskLogger {
+  readonly type: TaskLoggerOptions["type"];
+  public max: number;
+  #title: string;
+  #logger: any;
+  #verbose: boolean | undefined;
+  #parent: TaskLogger | undefined;
+  #index: number;
+
+  constructor(opts: TaskLoggerOptions) {
+    this.#title = opts.title;
+    this.type = opts.type;
+    this.#parent = opts.parent;
+    this.#verbose = opts.verbose;
+
+    this.#logger = this.create({
+      ...opts,
+      verbose: this.#verbose
+    });
+  }
+
+  get parent() {
+    return this.#parent;
+  }
+
+  get isReady() {
+    return !!this.#logger;
+  }
+
+  get title() {
+    return this.#title;
+  }
+
+  set title(title: string) {
+    if (title) {
+      this.#title = title;
+      this.#logger.message?.(title);
+    }
+  }
+
+  set output(message: string) {
+    if (message) {
+      (this.#logger.info || this.#logger.message)?.(message);
+    }
+  }
+
+  static from(opts: TaskLoggerOptions) {
+    if (opts.parent) {
+      switch (opts.parent.type) {
+        case "progress":
+          return new TaskLogger({
+            ...opts,
+            type: "progress",
+            parent: opts.parent
+          });
+        case "spinner":
+          return opts.parent;
+      }
+    }
+
+    if (opts.parent) {
+      if (opts.parent?.parent) {
+        opts.type = opts.type || "group";
+      } else {
+        opts.type = opts.type || "taskLog";
+      }
+    }
+
+    opts.type = opts.type || "log";
+
+    return new TaskLogger(opts);
+  }
+
+  log(message: string) {
+    this.#logger.message(`${this.title} - ${message}`);
+  }
+
+  message(message: string) {
+    this.#logger.message(`${this.title} - ${message}`);
+  }
+
+  advance() {
+    if (this.isReady && this.type === "progress") {
+      if (this.isRaw()) {
+        this.info(`${this.title} [${this.#index}/${this.parent!.max}]`);
+      } else {
+        const it = Math.round((1 / this.parent!.max) * 100);
+        this.#logger.advance(it, this.title);
+      }
+    }
+
+    return this;
+  }
+
+  start() {
+    if (this.isReady) {
+      const msg = `${this.title}...`;
+      switch (this.type) {
+        default:
+          this.#logger.message(msg);
+          break;
+        case "log":
+          this.#logger.info(msg);
+          break;
+        case "progress":
+          if (this.isChildProgress()) {
+            this.advance();
+          } else {
+            this.#logger.start(this.title);
+          }
+          break;
+        case "spinner":
+          this.#logger.start(this.title);
+          break;
+      }
+    }
+
+    return this;
+  }
+
+  done() {
+    if (this.isReady) {
+      const msg = `${this.title} completed`;
+
+      switch (this.type) {
+        default:
+          this.#logger.success(msg);
+          break;
+        case "progress":
+          if (!this.isChildProgress()) {
+            this.#logger.stop(msg);
+          }
+          break;
+        case "spinner":
+          this.#logger.stop(msg);
+          break;
+      }
+    }
+
+    return this;
+  }
+
+  error(message: string | Error) {
+    if (this.isReady) {
+      this.#logger.error(`${this.title} - ${message}`);
+    }
+
+    return this;
+  }
+
+  info(message: string) {
+    if (this.isReady) {
+      switch (this.type) {
+        case "log":
+        case "taskLog":
+          this.#logger.info(`${this.title} - ${message}`);
+          break;
+        default:
+          this.#logger.message(`${this.title} - ${message}`);
+          break;
+      }
+    }
+
+    return this;
+  }
+
+  warn(message: string) {
+    if (this.isReady) {
+      switch (this.type) {
+        case "log":
+        case "taskLog":
+          this.#logger.warn(`${this.title} - ${message}`);
+          break;
+        default:
+          this.#logger.message(`${this.title} - WARN ${message}`);
+      }
+    }
+
+    return this;
+  }
+
+  skip() {
+    if (this.isReady) {
+      switch (this.type) {
+        default:
+        case "log":
+          this.#logger.warn(`${this.title} skipped...`);
+          break;
+        case "group":
+        case "taskLog":
+          this.#logger.error(`${this.title} skipped...`);
+          break;
+        case "progress":
+          this.advance();
+          break;
+        case "spinner":
+          this.#logger.stop(`${this.title} skipped...`);
+          break;
+      }
+    }
+    return this;
+  }
+
+  /**
+   * @ddeprecated use info or message instead
+   * @param message
+   */
+  report(message: string) {
+    (this.#logger.info || this.#logger.message)?.(message);
+  }
+
+  protected isChildProgress() {
+    return this.parent?.type === "progress" && this.type === "progress";
+  }
+
+  protected create(opts: TaskLoggerOptions) {
+    const {type, title, parent} = opts;
+
+    if (this.isRaw()) {
+      const success = (message: string) => {
+        !this.isEnvTest() &&
+          contextLogger()?.info({
+            state: "SUCCESS",
+            title,
+            message
+          });
+      };
+      const start = (message: string) => {
+        !this.isEnvTest() &&
+          contextLogger()?.info({
+            title,
+            message
+          });
+      };
+      const defaultLogger = {
+        message: (message: string) => {
+          !this.isEnvTest() &&
+            contextLogger()?.info({
+              state: "MSG",
+              title,
+              message
+            });
+        },
+        stop: success,
+        success,
+        info: start,
+        start,
+        warn: (message: string) => {
+          !this.isEnvTest() &&
+            contextLogger()?.warn({
+              title,
+              message
+            });
+        },
+        error: (message: string) => {
+          !this.isEnvTest() &&
+            contextLogger()?.error({
+              title,
+              message
+            });
+        }
+      };
+
+      defaultLogger.message("...");
+      return defaultLogger;
+    }
+
+    switch (type) {
+      case "spinner":
+        const spin = spinner();
+        spin.message(title);
+
+        return spin;
+      case "progress":
+        if (parent && this.isChildProgress()) {
+          return parent.#logger;
+        }
+
+        return progress({
+          style: "block",
+          max: 100
+        });
+
+      case "taskLog":
+        return taskLog({
+          title: this.title
+        });
+
+      case "log":
+        return log;
+
+      case "group":
+        if (!parent || parent.type !== "taskLog") {
+          return log;
+        }
+
+        return parent.#logger.group(this.title);
+    }
+  }
+
+  private isRaw() {
+    return this.#verbose || this.isEnvTest();
+  }
+
+  private isEnvTest() {
+    return process.env.NODE_ENV === "test";
+  }
+}

package/src/fn/taskLogger.ts

@@ -0,0 +1,5 @@
+import {context, ContextLogger, contextLogger} from "@tsed/di";
+
+export function taskLogger(): ContextLogger {
+  return (context().get("TASK_LOGGER") as ContextLogger | undefined) || contextLogger();
+}

package/src/index.ts

@@ -0,0 +1,4 @@
+export * from "./domain/TaskLogger.js";
+export * from "./fn/taskLogger.js";
+export * from "./interfaces/Task.js";
+export * from "./tasks.js";

package/src/interfaces/Task.ts

@@ -0,0 +1,15 @@
+import type {Observable} from "rxjs";
+
+import {TaskLogger, type TaskLoggerOptions} from "../domain/TaskLogger.js";
+
+export type MaybePromise<T> = Promise<T> | T;
+
+type TaskPredicate = MaybePromise<boolean | string | undefined>;
+
+export interface Task<Ctx = any> {
+  title: string;
+  task: (ctx: Ctx, operation: TaskLogger) => MaybePromise<Task[] | unknown> | Observable<unknown>;
+  skip?: boolean | string | ((ctx: Ctx) => TaskPredicate);
+  enabled?: boolean | ((ctx: Ctx) => MaybePromise<boolean>);
+  type?: TaskLoggerOptions["type"];
+}