@tsed/cli-tasks 7.0.0-beta.13

package/src/tasks.spec.ts

@@ -0,0 +1,193 @@
+import {DITest, runInContext} from "@tsed/di";
+import {Observable} from "rxjs";
+import {afterEach, beforeEach, describe, expect, it, vi} from "vitest";
+
+import {TaskLogger, type TaskLoggerOptions} from "./domain/TaskLogger.js";
+import type {Task} from "./interfaces/Task.js";
+import {concat, tasks} from "./tasks.js";
+
+type LoggerStub = {
+  title: string;
+  type?: TaskLoggerOptions["type"];
+  parent?: TaskLogger;
+  max: number;
+  start: ReturnType<typeof vi.fn>;
+  done: ReturnType<typeof vi.fn>;
+  skip: ReturnType<typeof vi.fn>;
+  error: ReturnType<typeof vi.fn>;
+  message: ReturnType<typeof vi.fn>;
+  info: ReturnType<typeof vi.fn>;
+  warn: ReturnType<typeof vi.fn>;
+  advance: ReturnType<typeof vi.fn>;
+  log: ReturnType<typeof vi.fn>;
+  report: ReturnType<typeof vi.fn>;
+};
+
+function createLoggerStub(opts: TaskLoggerOptions) {
+  const stub: LoggerStub = {
+    title: opts.title,
+    type: opts.type,
+    parent: opts.parent,
+    max: 0,
+    start: vi.fn().mockReturnThis(),
+    done: vi.fn().mockReturnThis(),
+    skip: vi.fn().mockReturnThis(),
+    error: vi.fn().mockReturnThis(),
+    message: vi.fn().mockReturnThis(),
+    info: vi.fn().mockReturnThis(),
+    warn: vi.fn().mockReturnThis(),
+    advance: vi.fn().mockReturnThis(),
+    log: vi.fn().mockReturnThis(),
+    report: vi.fn().mockReturnThis()
+  };
+
+  return stub as LoggerStub & TaskLogger;
+}
+
+function mockTaskLoggers() {
+  const loggers = new Map<string, LoggerStub & TaskLogger>();
+  vi.spyOn(TaskLogger, "from").mockImplementation((opts) => {
+    const stub = createLoggerStub(opts);
+    loggers.set(opts.title, stub);
+    return stub;
+  });
+
+  return loggers;
+}
+
+describe("tasks()", () => {
+  beforeEach(() =>
+    DITest.create({
+      env: "test"
+    })
+  );
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    return DITest.reset();
+  });
+
+  it("logs each emission from observable task results", async () => {
+    const loggers = mockTaskLoggers();
+
+    const observableTask$ = new Observable<string>((subscriber) => {
+      subscriber.next("first-line");
+      subscriber.next("second-line");
+      subscriber.complete();
+    });
+
+    const observableTask: Task = {
+      title: "Observable task",
+      task: () => observableTask$
+    };
+
+    const ctx = DITest.createDIContext();
+
+    await runInContext(ctx, () => tasks([observableTask], {}));
+
+    const logger = loggers.get("Observable task");
+    expect(logger?.message).toHaveBeenCalledTimes(2);
+    expect(logger?.message).toHaveBeenNthCalledWith(1, "first-line");
+    expect(logger?.message).toHaveBeenNthCalledWith(2, "second-line");
+  });
+
+  it("skips tasks when enabled predicate resolves false", async () => {
+    const loggers = mockTaskLoggers();
+    const disabledSpy = vi.fn();
+    const activeSpy = vi.fn();
+
+    const ctx = DITest.createDIContext();
+    await runInContext(ctx, () =>
+      tasks(
+        [
+          {
+            title: "Disabled task",
+            enabled: () => false,
+            task: disabledSpy
+          },
+          {
+            title: "Active task",
+            task: activeSpy
+          }
+        ],
+        {}
+      )
+    );
+
+    expect(disabledSpy).not.toHaveBeenCalled();
+    expect(activeSpy).toHaveBeenCalledTimes(1);
+    expect(loggers.get("Disabled task")?.skip).toHaveBeenCalledTimes(1);
+    expect(loggers.get("Active task")?.start).toHaveBeenCalledTimes(1);
+    expect(loggers.get("Active task")?.done).toHaveBeenCalledTimes(1);
+  });
+
+  it("skips tasks when skip predicate resolves truthy", async () => {
+    const loggers = mockTaskLoggers();
+    const skippedSpy = vi.fn();
+
+    const ctx = DITest.createDIContext();
+    await runInContext(ctx, () =>
+      tasks(
+        [
+          {
+            title: "Skippable task",
+            skip: () => "skip",
+            task: skippedSpy
+          }
+        ],
+        {}
+      )
+    );
+
+    expect(skippedSpy).not.toHaveBeenCalled();
+    expect(loggers.get("Skippable task")?.skip).toHaveBeenCalledTimes(1);
+  });
+
+  it("runs nested tasks returned from a task result", async () => {
+    const loggers = mockTaskLoggers();
+    const order: string[] = [];
+
+    const ctx = DITest.createDIContext();
+    await runInContext(ctx, () =>
+      tasks(
+        [
+          {
+            title: "Parent task",
+            task: () => [
+              {
+                title: "Child sync",
+                task: () => {
+                  order.push("sync");
+                }
+              },
+              {
+                title: "Child async",
+                task: () =>
+                  Promise.resolve().then(() => {
+                    order.push("async");
+                  })
+              }
+            ]
+          }
+        ],
+        {}
+      )
+    );
+
+    expect(order).toEqual(["sync", "async"]);
+    expect(loggers.get("Child sync")?.start).toHaveBeenCalledTimes(1);
+    expect(loggers.get("Child async")?.done).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe("concat()", () => {
+  it("merges task arrays while ignoring empty entries", async () => {
+    const taskA: Task = {title: "A", task: vi.fn()};
+    const taskB: Task = {title: "B", task: vi.fn()};
+    const taskC: Task = {title: "C", task: vi.fn()};
+
+    const result = await concat([taskA], undefined, [], [taskB, taskC]);
+
+    expect(result).toEqual([taskA, taskB, taskC]);
+  });
+});

package/src/tasks.ts

@@ -0,0 +1,131 @@
+import {isArray} from "@tsed/core/utils/isArray";
+import {isBoolean} from "@tsed/core/utils/isBoolean";
+import {isFunction} from "@tsed/core/utils/isFunction";
+import {isObservable} from "@tsed/core/utils/isObservable";
+import {isPromise} from "@tsed/core/utils/isPromise";
+import {isString} from "@tsed/core/utils/isString";
+import {context} from "@tsed/di";
+
+import {TaskLogger, type TaskLoggerOptions} from "./domain/TaskLogger.js";
+import type {Task} from "./interfaces/Task.js";
+
+export interface TasksOptions {
+  verbose?: TaskLoggerOptions["verbose"];
+}
+
+export async function tasks<T = any>(list: Task[], ctx: T & TasksOptions, parent?: TaskLogger) {
+  const items = list.filter((task) => isEnabled(task));
+
+  parent && (parent.max = items.length);
+
+  for (let i = 0; i < items.length; i++) {
+    const task = items[i];
+
+    const taskLogger = TaskLogger.from({
+      index: i,
+      title: task.title,
+      type: task.type,
+      parent,
+      verbose: ctx.verbose
+    });
+
+    try {
+      if (!(await isExecutable(task, ctx))) {
+        taskLogger.skip();
+        continue;
+      }
+
+      taskLogger.start();
+
+      context().set("TASK_LOGGER", taskLogger);
+
+      const result = await resolveTaskResult(task.task(ctx, taskLogger), taskLogger);
+
+      context().delete("TASK_LOGGER");
+
+      if (isArray(result)) {
+        await tasks(result, ctx, taskLogger);
+      }
+
+      taskLogger.done();
+    } catch (er) {
+      taskLogger.error(er);
+      throw er;
+    }
+  }
+}
+
+function resolveTaskResult(result: any, logger: TaskLogger): Promise<any> | any {
+  if (!result) {
+    return result;
+  }
+
+  if (isPromise(result)) {
+    return result;
+  }
+
+  if (isObservable(result)) {
+    return new Promise((resolve, reject) => {
+      let subscription: any;
+      subscription = result.subscribe({
+        next(value: unknown) {
+          if (isString(value)) {
+            logger.message(value);
+          }
+        },
+        complete() {
+          subscription?.unsubscribe?.();
+          resolve(undefined);
+        },
+        error(err: any) {
+          subscription?.unsubscribe?.();
+          reject(err);
+        }
+      });
+    });
+  }
+
+  return result;
+}
+
+export async function concat(...args: (Task[] | void | undefined)[]) {
+  const tasks: Task[] = [];
+
+  for (const arg of args) {
+    if (isArray(arg)) {
+      tasks.push(...arg);
+    }
+  }
+
+  return tasks;
+}
+
+function isEnabled(item: Task<any>) {
+  return isBoolean(item.enabled) ? item.enabled : true;
+}
+
+async function isExecutable<CTX = any>(item: Task, ctx: CTX): Promise<boolean> {
+  if (isFunction(item.enabled)) {
+    const isEnable = await item.enabled(ctx);
+
+    if (!isEnable) {
+      return false;
+    }
+  }
+
+  if ("skip" in item) {
+    const isSkipped = isFunction(item.skip) ? await item.skip(ctx) : item.skip;
+
+    if (isSkipped) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+/**
+ * @deprecated use tasks function instead
+ */
+export const createTasksRunner = tasks;
+export const createSubTasks = tasks;

package/test.js

@@ -0,0 +1,68 @@
+import {log, progress, spinner, taskLog} from "@clack/prompts";
+
+async function extracted() {
+  // const log1 = taskLog({title: "Starting task..."});
+  //
+  // await new Promise((r) => setTimeout(r, 1000));
+  //
+  // log1.message("Message");
+  //
+  // await new Promise((r) => setTimeout(r, 1000));
+  //
+  // const group = log1.group("Subtask 1");
+  // await new Promise((r) => setTimeout(r, 1000));
+  //
+  // group.message("Subtask message");
+  //
+  // await new Promise((r) => setTimeout(r, 1000));
+  //
+  // group.message("Subtask message");
+  //
+  // await new Promise((r) => setTimeout(r, 1000));
+  //
+  // group.success("Subtask message 2");
+  //
+  // await new Promise((r) => setTimeout(r, 1000));
+  //
+  // const group2 = log1.group("Subtask 2");
+  //
+  // await new Promise((r) => setTimeout(r, 1000));
+  //
+  // group2.message("Subtask 2 message");
+  //
+  // const spin = spinner(); //
+  // spin.start("Loading...");
+  //
+  // await new Promise((r) => setTimeout(r, 1000));
+  //
+  // spin.stop("Loading...");
+  // spin.clear();
+  //
+  // log1.success("Message");
+  //
+
+  // const task = taskLog({title: "Starting task..."});
+  const p = progress({
+    style: "block",
+    max: 100
+  });
+
+  p.start("Preparing...");
+
+  await new Promise((r) => setTimeout(r, 1000));
+
+  p.advance(10, "Install...");
+
+  await new Promise((r) => setTimeout(r, 1000));
+
+  p.advance(50, "Update...");
+
+  await new Promise((r) => setTimeout(r, 1000));
+
+  p.advance(90, "Update...");
+  //
+  // p.stop("Complete!");
+}
+
+await extracted();
+// await extracted();

package/tsconfig.esm.json

@@ -0,0 +1,27 @@
+{
+  "extends": "@tsed/typescript/tsconfig.node.json",
+  "compilerOptions": {
+    "baseUrl": ".",
+    "rootDir": "src",
+    "outDir": "./lib/esm",
+    "declarationDir": "./lib/types",
+    "declaration": true,
+    "composite": true,
+    "noEmit": false,
+    "sourceMap": false
+  },
+  "include": ["src", "src/**/*.json"],
+  "exclude": [
+    "node_modules",
+    "test",
+    "lib",
+    "benchmark",
+    "coverage",
+    "spec",
+    "**/*.benchmark.ts",
+    "**/*.spec.ts",
+    "keys",
+    "**/__mock__/**",
+    "webpack.config.js"
+  ]
+}

package/vitest.config.mts

@@ -0,0 +1,20 @@
+// @ts-ignore
+import {presets} from "@tsed/vitest/presets";
+import {defineConfig} from "vitest/config";
+
+export default defineConfig({
+  ...presets,
+  test: {
+    ...presets.test,
+    setupFiles: ["reflect-metadata"],
+    coverage: {
+      ...presets.test?.coverage,
+      thresholds: {
+        statements: 0,
+        branches: 0,
+        functions: 0,
+        lines: 0
+      }
+    }
+  }
+});