@runium/cli 0.0.2 → 0.0.3

package/src/macros/path.ts

@@ -0,0 +1,24 @@
+import { resolve } from 'node:path';
+import { homedir, tmpdir } from 'node:os';
+
+/**
+ * Resolve path
+ * @param path
+ */
+export function pathMacro(...path: string[]): string {
+  return resolve(...path);
+}
+
+/**
+ * Tmpdir path
+ */
+export function tmpDirMacro(): string {
+  return tmpdir();
+}
+
+/**
+ * Home directory path
+ */
+export function homeDirMacro(): string {
+  return homedir();
+}

package/src/services/command.ts

@@ -0,0 +1,171 @@
+import { Command } from 'commander';
+import { Container, Service } from 'typedi';
+import { isRuniumError, RuniumError } from '@runium/core';
+import { ErrorCode } from '@constants';
+import { PluginService } from '@services';
+import {
+  RuniumCommand,
+  RuniumCommandConstructor,
+} from '@commands/runium-command.js';
+
+const PROGRAM_NAME = 'runium';
+
+@Service()
+export class CommandService {
+  /**
+   * Full path commands
+   */
+  private fullPathCommands: Map<string, RuniumCommand> = new Map();
+
+  /**
+   * Get command full path recursively
+   * @param command
+   */
+  private getCommandFullPath(command: RuniumCommand): string {
+    const commandName = command.command?.name();
+
+    if (commandName === PROGRAM_NAME || !command.command.parent) {
+      return '';
+    }
+
+    // find the parent command instance
+    const parentCommand = Array.from(this.fullPathCommands.values()).find(
+      cmd => cmd.command === command.command.parent
+    );
+
+    if (parentCommand) {
+      // recursively get parent's full path
+      const parentPath = this.getCommandFullPath(parentCommand);
+      return [parentPath, commandName].filter(Boolean).join(' ').trim();
+    }
+
+    // fallback: if parent not found in map, check if parent is the program
+    const parentName = command.command.parent.name();
+    if (parentName === PROGRAM_NAME) {
+      return commandName;
+    }
+
+    return [parentName, commandName].join(' ').trim();
+  }
+
+  /**
+   * Register command
+   * @param command
+   * @param program
+   * @param context
+   */
+  registerCommand(
+    command: RuniumCommandConstructor,
+    program: Command,
+    context: string = 'app'
+  ): void {
+    const addCommand = (
+      CommandConstructor: RuniumCommandConstructor,
+      parent: Command
+    ) => {
+      try {
+        if (!(CommandConstructor.prototype instanceof RuniumCommand)) {
+          throw new RuniumError(
+            `Command "${CommandConstructor.name}" for "${context}" must be a subclass of "RuniumCommand"`,
+            ErrorCode.COMMAND_INCORRECT,
+            {
+              context,
+              CommandConstructor,
+            }
+          );
+        }
+
+        const commandInstance: RuniumCommand = new CommandConstructor(parent);
+
+        const commandPath = this.getCommandFullPath(commandInstance);
+        this.fullPathCommands.set(commandPath, commandInstance);
+
+        if (commandInstance.subcommands.length > 0) {
+          commandInstance.subcommands.forEach(subcommand => {
+            addCommand(subcommand, commandInstance.command);
+          });
+        }
+      } catch (error) {
+        if (isRuniumError(error)) {
+          throw error;
+        }
+        throw new RuniumError(
+          `Failed to register command "${CommandConstructor.name}" for "${context}"`,
+          ErrorCode.COMMAND_REGISTRATION_ERROR,
+          { original: error }
+        );
+      }
+    };
+
+    addCommand(command, program);
+  }
+
+  /**
+   * Create run command
+   * @param handle
+   * @param command
+   */
+  createRunCommand(
+    handle: (...args: unknown[]) => Promise<void>,
+    command: RuniumCommand
+  ): (...args: unknown[]) => Promise<void> {
+    const pluginService = Container.get(PluginService);
+    return async (...args: unknown[]): Promise<void> => {
+      // run from command action contains command
+      // run from plugin context does not contain command
+      if (args?.length > 0 && args[args.length - 1] instanceof Command) {
+        args.pop();
+      }
+
+      const commandPath = this.getCommandFullPath(command);
+
+      await pluginService.runHook('app.beforeCommandRun', {
+        command: commandPath,
+        args,
+      });
+
+      await handle.call(command, ...args);
+
+      await pluginService.runHook('app.afterCommandRun', {
+        command: commandPath,
+        args,
+      });
+    };
+  }
+
+  /**
+   * Check if command exists
+   * @param path
+   */
+  hasCommand(path: string): boolean {
+    return this.fullPathCommands.has(path);
+  }
+
+  /**
+   * Run command
+   * @param path
+   * @param args
+   */
+  async runCommand(path: string, ...args: unknown[]): Promise<void> {
+    const command = this.fullPathCommands.get(path);
+    if (!command) {
+      throw new RuniumError(
+        `Command "${path}" not found`,
+        ErrorCode.COMMAND_NOT_FOUND,
+        { path }
+      );
+    }
+    try {
+      await command.run(...args);
+    } catch (error) {
+      if (isRuniumError(error)) {
+        throw error;
+      }
+      throw new RuniumError(
+        `Failed to run command "${path}"`,
+        ErrorCode.COMMAND_RUN_ERROR,
+        { original: error }
+      );
+    }
+  }
+}

package/src/services/config.ts

@@ -0,0 +1,119 @@
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { Service } from 'typedi';
+import { readJsonFile, RuniumError } from '@runium/core';
+import { ErrorCode } from '@constants';
+import {
+  createValidator,
+  getConfigSchema,
+  getErrorMessages,
+} from '@validation';
+
+interface ConfigEnv {
+  path: string[];
+}
+
+interface ConfigOutput {
+  debug: boolean;
+}
+
+interface ConfigProfile {
+  path: string;
+}
+
+interface ConfigPlugin {
+  disabled: boolean;
+  options: Record<string, unknown>;
+}
+
+interface ConfigPlugins {
+  [name: string]: ConfigPlugin;
+}
+
+interface ConfigData {
+  env: ConfigEnv;
+  output: ConfigOutput;
+  profile: ConfigProfile;
+  plugins: ConfigPlugins;
+}
+
+const CONFIG_FILE_NAME = '.runiumrc.json';
+const CONFIG_FILE_PATH = join(process.cwd(), CONFIG_FILE_NAME);
+const PROFILE_DIR_NAME = '.runium';
+const HOME_PROFILE_PATH = join(homedir(), PROFILE_DIR_NAME);
+const CWD_PROFILE_PATH = join(process.cwd(), PROFILE_DIR_NAME);
+
+/**
+ * Validate config data
+ * @param data
+ */
+function validateConfigData(data: unknown): void {
+  const schema = getConfigSchema();
+  const validate = createValidator(schema);
+  const result = validate(data);
+
+  if (!result && validate.errors) {
+    const errorMessages = getErrorMessages(validate.errors);
+
+    throw new RuniumError(
+      `Invalid "${CONFIG_FILE_PATH}" configuration data`,
+      ErrorCode.CONFIG_INVALID_DATA,
+      errorMessages
+    );
+  }
+}
+
+@Service()
+export class ConfigService {
+  private data: ConfigData = {
+    profile: { path: HOME_PROFILE_PATH },
+    plugins: {},
+    output: { debug: false },
+    env: { path: [] },
+  };
+
+  /**
+   * Initialize the config service
+   */
+  async init(): Promise<void> {
+    if (existsSync(CWD_PROFILE_PATH)) {
+      this.data.profile.path = CWD_PROFILE_PATH;
+    }
+
+    if (existsSync(CONFIG_FILE_PATH)) {
+      const configData: Partial<ConfigData> =
+        await readJsonFile<Partial<ConfigData>>(CONFIG_FILE_PATH);
+      if (configData) {
+        validateConfigData(configData);
+
+        const data = {
+          env: Object.assign({}, this.data.env, configData.env ?? {}),
+          output: Object.assign({}, this.data.output, configData.output ?? {}),
+          profile: Object.assign(
+            {},
+            this.data.profile,
+            configData.profile ?? {}
+          ),
+          plugins: Object.assign(
+            {},
+            this.data.plugins,
+            configData.plugins ?? {}
+          ),
+        };
+
+        data.env.path = data.env.path.map(envPath => resolve(envPath));
+        data.profile.path = resolve(data.profile.path);
+        this.data = data;
+      }
+    }
+  }
+
+  /**
+   * Get a configuration value
+   * @param key
+   */
+  get<T extends keyof ConfigData>(key: T): ConfigData[T] {
+    return this.data[key];
+  }
+}

package/src/services/file.ts

@@ -0,0 +1,272 @@
+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

@@ -0,0 +1,9 @@
+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';