@runium/cli 0.0.3 → 0.0.5

package/src/services/file.ts

@@ -1,272 +0,0 @@
-import { PathLike } from 'node:fs';
-import { basename, dirname, join } from 'node:path';
-import {
-  access,
-  constants,
-  mkdir,
-  readFile,
-  rename,
-  writeFile,
-} from 'node:fs/promises';
-import { fileURLToPath } from 'node:url';
-
-import { Service } from 'typedi';
-import { JSONObject, RuniumError } from '@runium/core';
-import { ErrorCode } from '@constants';
-
-type Resolve = () => void;
-type Reject = (error: Error) => void;
-type Data = Parameters<typeof writeFile>[1];
-
-@Service()
-export class FileService {
-  /**
-   * Reads a file as text
-   * @param path
-   * @param options
-   */
-  async read(
-    path: string,
-    options: { encoding?: BufferEncoding } = {}
-  ): Promise<string> {
-    try {
-      return await readFile(path, { encoding: options.encoding || 'utf-8' });
-    } catch (ex) {
-      throw new RuniumError(
-        `Can not read file ${path}`,
-        ErrorCode.FILE_READ_ERROR,
-        { path, options, original: ex }
-      );
-    }
-  }
-
-  /**
-   * Writes data to a file
-   * @param path
-   * @param data
-   * @param options
-   */
-  async write(
-    path: string,
-    data: string,
-    options: { encoding?: BufferEncoding } = {}
-  ): Promise<void> {
-    try {
-      await writeFile(path, data, { encoding: options.encoding || 'utf-8' });
-    } catch (ex) {
-      throw new RuniumError(
-        `Can not write file ${path}`,
-        ErrorCode.FILE_WRITE_ERROR,
-        { path, data, options, original: ex }
-      );
-    }
-  }
-
-  /**
-   * Reads a JSON file
-   * @param path
-   */
-  async readJson<T = JSONObject>(path: string): Promise<T> {
-    try {
-      const data = await readFile(path, { encoding: 'utf-8' });
-      return JSON.parse(data);
-    } catch (ex) {
-      throw new RuniumError(
-        `Can not read JSON file ${path}`,
-        ErrorCode.FILE_READ_JSON_ERROR,
-        { path, original: ex }
-      );
-    }
-  }
-
-  /**
-   * Writes a JSON file
-   * @param path
-   * @param data
-   */
-  async writeJson<T = JSONObject>(path: string, data: T): Promise<void> {
-    try {
-      await writeFile(path, JSON.stringify(data, null, 2), {
-        encoding: 'utf-8',
-      });
-    } catch (ex) {
-      throw new RuniumError(
-        `Can not write JSON file ${path}`,
-        ErrorCode.FILE_WRITE_JSON_ERROR,
-        { path, data, original: ex }
-      );
-    }
-  }
-
-  /**
-   * Checks if a file or directory exists
-   * @param path
-   */
-  async isExists(path: string): Promise<boolean> {
-    try {
-      await access(path, constants.F_OK);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  /**
-   * Create directory recursively if it does not exist
-   * @param path
-   */
-  async ensureDirExists(path: string): Promise<void> {
-    try {
-      await mkdir(path, { recursive: true });
-    } catch (ex) {
-      throw new RuniumError(
-        `Can not create directory ${path}`,
-        ErrorCode.FILE_CREATE_DIR_ERROR,
-        { path, original: ex }
-      );
-    }
-  }
-
-  /**
-   * Create an atomic file writer
-   * @param path
-   */
-  createAtomicWriter(path: PathLike): AtomicWriter {
-    return new AtomicWriter(path);
-  }
-}
-
-/**
- * Creates a temporary file name for a given file
- * @param file
- */
-function getTempFilename(file: PathLike): string {
-  const f = file instanceof URL ? fileURLToPath(file) : file.toString();
-  return join(dirname(f), `.${basename(f)}.tmp`);
-}
-
-/**
- * Retries an asynchronous operation with a delay between retries and a maximum retry count
- * @param fn
- * @param maxRetries
- * @param delayMs
- */
-async function retryAsyncOperation(
-  fn: () => Promise<void>,
-  maxRetries: number,
-  delayMs: number
-): Promise<void> {
-  for (let i = 0; i < maxRetries; i++) {
-    try {
-      return await fn();
-    } catch (error) {
-      if (i < maxRetries - 1) {
-        await new Promise(resolve => setTimeout(resolve, delayMs));
-      } else {
-        throw error;
-      }
-    }
-  }
-}
-
-/**
- * Atomic file writer
- *
- * Allows writing to a file atomically
- * based on https://github.com/typicode/steno
- */
-export class AtomicWriter {
-  private readonly filename: PathLike;
-  private readonly tempFilename: PathLike;
-  private locked = false;
-  private prev: [Resolve, Reject] | null = null;
-  private next: [Resolve, Reject] | null = null;
-  private nextPromise: Promise<void> | null = null;
-  private nextData: Data | null = null;
-
-  constructor(filename: PathLike) {
-    this.filename = filename;
-    this.tempFilename = getTempFilename(filename);
-  }
-
-  /**
-   * Add data for later write
-   * @param data
-   */
-  private addData(data: Data): Promise<void> {
-    // keep only most recent data
-    this.nextData = data;
-
-    // create a singleton promise to resolve all next promises once next data is written
-    this.nextPromise ||= new Promise((resolve, reject) => {
-      this.next = [resolve, reject];
-    });
-
-    // return a promise that will resolve at the same time as next promise
-    return new Promise((resolve, reject) => {
-      this.nextPromise?.then(resolve).catch(reject);
-    });
-  }
-
-  /**
-   * Write data to a file atomically
-   * @param data
-   */
-  private async writeData(data: Data): Promise<void> {
-    this.locked = true;
-    try {
-      await writeFile(this.tempFilename, data, 'utf-8');
-      await retryAsyncOperation(
-        async () => {
-          await rename(this.tempFilename, this.filename);
-        },
-        10,
-        100
-      );
-
-      // resolve
-      this.prev?.[0]();
-    } catch (err) {
-      // reject
-      if (err instanceof Error) {
-        this.prev?.[1](err);
-      }
-      throw err;
-    } finally {
-      this.locked = false;
-
-      this.prev = this.next;
-      this.next = this.nextPromise = null;
-
-      if (this.nextData !== null) {
-        const nextData = this.nextData;
-        this.nextData = null;
-        await this.write(nextData);
-      }
-    }
-  }
-
-  /**
-   * Write data to a file atomically
-   * @param data
-   */
-  async write(data: Data): Promise<void> {
-    try {
-      await (this.locked ? this.addData(data) : this.writeData(data));
-    } catch (ex) {
-      throw new RuniumError(
-        `Can not write file ${this.filename}`,
-        ErrorCode.FILE_WRITE_ERROR,
-        { path: this.filename, data, original: ex }
-      );
-    }
-  }
-
-  /**
-   * Writes a JSON file
-   * @param data
-   */
-  async writeJson<T = JSONObject>(data: T): Promise<void> {
-    return this.write(JSON.stringify(data, null, 2));
-  }
-}

package/src/services/index.ts

@@ -1,9 +0,0 @@
-export * from './command.js';
-export * from './config.js';
-export * from './file.js';
-export * from './output.js';
-export * from './profile.js';
-export * from './plugin.js';
-export * from './project.js';
-export * from './shutdown.js';
-export * from './plugin-context.js';

package/src/services/output.ts

@@ -1,205 +0,0 @@
-import { Console } from 'node:console';
-import { Transform } from 'node:stream';
-import { inspect } from 'node:util';
-
-import { Service } from 'typedi';
-
-export enum OutputLevel {
-  TRACE = 0,
-  DEBUG = 1,
-  INFO = 2,
-  WARN = 3,
-  ERROR = 4,
-  SILENT = 5,
-}
-
-/**
- * Console dumper
- * wrapper around node console with a transform stream
- */
-class ConsoleDumper extends Console {
-  private readonly transform: Transform;
-
-  constructor() {
-    inspect.defaultOptions.depth = 5;
-
-    const transform = new Transform({
-      transform: (chunk, _, cb) => cb(null, chunk),
-    });
-    super({
-      stdout: transform,
-      stderr: transform,
-      colorMode: false,
-    });
-    this.transform = transform;
-  }
-
-  /**
-   * Get a table output with index column removed
-   * @param data
-   * @param columns
-   */
-  getPatchedTable(data: unknown[], columns?: string[]): string {
-    this.table(data, columns);
-
-    const original = (this.transform.read() || '').toString();
-
-    // Tables should all start with roughly:
-    // ┌─────────┬──────
-    // │ (index) │
-    // ├─────────┼
-    const columnWidth = original.indexOf('┬') + 1;
-
-    return original
-      .split('\n')
-      .map((line: string) => line.charAt(0) + line.slice(columnWidth))
-      .join('\n')
-      .replace(/'([^']*)'/g, '$1  ');
-  }
-}
-
-const dumper = new ConsoleDumper();
-
-@Service()
-export class OutputService {
-  private outputLevel: OutputLevel = OutputLevel.INFO;
-
-  /**
-   * Set output level
-   * @param level
-   */
-  setLevel(level: OutputLevel): void {
-    this.outputLevel = level;
-  }
-
-  /**
-   * Get output level
-   */
-  getLevel(): OutputLevel {
-    return this.outputLevel;
-  }
-
-  /**
-   * Log a trace message
-   * @param message
-   * @param args
-   */
-  trace(message: string, ...args: unknown[]): void {
-    if (this.outputLevel <= OutputLevel.TRACE) {
-      // eslint-disable-next-line no-console
-      console.log(message, ...args);
-    }
-  }
-
-  /**
-   * Log a debug message
-   * @param message
-   * @param args
-   */
-  debug(message: string, ...args: unknown[]): void {
-    if (this.outputLevel <= OutputLevel.DEBUG) {
-      // eslint-disable-next-line no-console
-      console.log(message, ...args);
-    }
-  }
-
-  /**
-   * Log an info message
-   * @param message
-   * @param args
-   */
-  info(message: string, ...args: unknown[]): void {
-    if (this.outputLevel <= OutputLevel.INFO) {
-      // eslint-disable-next-line no-console
-      console.log(message, ...args);
-    }
-  }
-
-  /**
-   * Log a success message
-   * @param message
-   * @param args
-   */
-  success(message: string, ...args: unknown[]): void {
-    if (this.outputLevel <= OutputLevel.INFO) {
-      // eslint-disable-next-line no-console
-      console.log(message, ...args);
-    }
-  }
-
-  /**
-   * Log a warning message
-   * @param message
-   * @param args
-   */
-  warn(message: string, ...args: unknown[]): void {
-    if (this.outputLevel <= OutputLevel.WARN) {
-      // eslint-disable-next-line no-console
-      console.warn(message, ...args);
-    }
-  }
-
-  /**
-   * Log an error message
-   * @param message
-   * @param args
-   */
-  error(message: string, ...args: unknown[]): void {
-    if (this.outputLevel <= OutputLevel.ERROR) {
-      // eslint-disable-next-line no-console
-      console.error(message, ...args);
-    }
-  }
-
-  /**
-   * Log a message without level
-   * @param message
-   * @param args
-   */
-  log(message: string, ...args: unknown[]): void {
-    if (this.outputLevel < OutputLevel.SILENT) {
-      // eslint-disable-next-line no-console
-      console.log(message, ...args);
-    }
-  }
-
-  /**
-   * Output a table
-   * @param data
-   * @param columns
-   */
-  table(data: unknown[], columns?: string[]): void {
-    if (this.outputLevel < OutputLevel.SILENT) {
-      const patchedData = data.map((item, index) => ({
-        ...(item as object),
-        '#': index + 1,
-      }));
-      const patchedOutput = dumper.getPatchedTable(
-        patchedData,
-        columns ? ['#', ...columns] : undefined
-      );
-      // eslint-disable-next-line no-console
-      console.log(patchedOutput);
-    }
-  }
-
-  /**
-   * Output a blank line
-   */
-  newLine(): void {
-    if (this.outputLevel < OutputLevel.SILENT) {
-      // eslint-disable-next-line no-console
-      console.log('');
-    }
-  }
-
-  /**
-   * Clear output
-   */
-  clear(): void {
-    if (this.outputLevel < OutputLevel.SILENT) {
-      // eslint-disable-next-line no-console
-      console.clear();
-    }
-  }
-}

package/src/services/plugin-context.ts

@@ -1,140 +0,0 @@
-import { delimiter } from 'node:path';
-import { Inject, Service } from 'typedi';
-import {
-  RuniumError,
-  isRuniumError,
-  RuniumTask,
-  RuniumTrigger,
-  applyMacros,
-  TaskEvent,
-  TaskStatus,
-  ProjectEvent,
-  ProjectStatus,
-} from '@runium/core';
-import { RuniumCommand } from '@commands/runium-command.js';
-import {
-  CommandService,
-  FileService,
-  OutputLevel,
-  OutputService,
-  ProfileService,
-  ShutdownService,
-} from '@services';
-import { getVersion } from '@utils';
-import { ErrorCode } from '@constants';
-
-global.runium = null;
-
-@Service()
-export class PluginContextService {
-  constructor(
-    @Inject() private commandService: CommandService,
-    @Inject() private outputService: OutputService,
-    @Inject() private shutdownService: ShutdownService,
-    @Inject() private fileService: FileService,
-    @Inject() private profileService: ProfileService
-  ) {}
-
-  /**
-   * Create a wrapper for a file service method that processes path parts
-   * @param methodName
-   */
-  private createStorageWrapper<T extends keyof FileService>(
-    methodName: T
-  ): FileService[T] {
-    return ((...args: unknown[]) => {
-      const [pathParts, ...rest] = args;
-      const resolvedPath = this.resolveProfilePath(
-        pathParts as string | string[]
-      );
-      const method = this.fileService[methodName] as (
-        ...args: unknown[]
-      ) => unknown;
-      return method(resolvedPath, ...rest);
-    }) as FileService[T];
-  }
-
-  /**
-   * Resolve path parts using profileService
-   * @param pathParts
-   */
-  private resolveProfilePath(pathParts: string | string[]): string {
-    const parts = Array.isArray(pathParts)
-      ? pathParts
-      : pathParts.split(delimiter);
-    if (parts.length === 0 || parts.every(part => part.trim() === '')) {
-      throw new RuniumError('Invalid path', ErrorCode.INVALID_PATH, {
-        path: pathParts,
-      });
-    }
-    return this.profileService.getPath(...parts);
-  }
-
-  /**
-   * Initialize the plugin context service
-   */
-  async init(): Promise<void> {
-    const command = this.commandService;
-    const output = this.outputService;
-    const shutdown = this.shutdownService;
-
-    const runium = {
-      class: {
-        RuniumCommand,
-        RuniumError,
-        RuniumTask,
-        RuniumTrigger,
-      },
-      enum: {
-        OutputLevel: Object.keys(OutputLevel)
-          .filter(key => isNaN(Number(key)))
-          .reduce(
-            (acc, key) => {
-              acc[key] = OutputLevel[key as keyof typeof OutputLevel];
-              return acc;
-            },
-            {} as Record<string, number>
-          ),
-        ProjectEvent,
-        ProjectStatus,
-        TaskEvent,
-        TaskStatus,
-      },
-      utils: {
-        applyMacros,
-        isRuniumError,
-      },
-      output: {
-        getLevel: output.getLevel.bind(output),
-        setLevel: output.setLevel.bind(output),
-        trace: output.trace.bind(output),
-        debug: output.debug.bind(output),
-        info: output.info.bind(output),
-        warn: output.warn.bind(output),
-        error: output.error.bind(output),
-        table: output.table.bind(output),
-        log: output.log.bind(output),
-      },
-      shutdown: {
-        addBlocker: shutdown.addBlocker.bind(shutdown),
-        removeBlocker: shutdown.removeBlocker.bind(shutdown),
-      },
-      command: {
-        has: command.hasCommand.bind(command),
-        run: command.runCommand.bind(command),
-      },
-      storage: {
-        read: this.createStorageWrapper('read'),
-        write: this.createStorageWrapper('write'),
-        readJson: this.createStorageWrapper('readJson'),
-        writeJson: this.createStorageWrapper('writeJson'),
-        isExists: this.createStorageWrapper('isExists'),
-        ensureDirExists: this.createStorageWrapper('ensureDirExists'),
-        createAtomicWriter: this.createStorageWrapper('createAtomicWriter'),
-        getPath: this.resolveProfilePath.bind(this),
-      },
-      version: getVersion(),
-    };
-    global.runium = Object.freeze(runium);
-  }
-}