@runium/cli 0.0.3 → 0.0.4

package/src/services/plugin.ts

@@ -1,248 +0,0 @@
-import { existsSync } from 'node:fs';
-import { resolve } from 'node:path';
-import { Inject, Service } from 'typedi';
-import {
-  isRuniumError,
-  MacrosCollection,
-  Project,
-  ProjectConfig,
-  ProjectSchemaExtension,
-  RuniumError,
-  RuniumTaskConstructor,
-  RuniumTriggerConstructor,
-  RuniumTriggerOptions,
-} from '@runium/core';
-import { RuniumCommandConstructor } from '@commands/runium-command.js';
-import { ErrorCode } from '@constants';
-import { OutputService } from '@services';
-import {
-  createValidator,
-  getErrorMessages,
-  getPluginSchema,
-} from '@validation';
-
-type PluginModule = { default: (options?: PluginOptions) => Plugin };
-
-type PluginHookErrorHandler = (error: RuniumError) => void;
-
-type PluginHookName =
-  | `app.${keyof PluginAppHooksDefinition}`
-  | `project.${keyof PluginProjectHooksDefinition}`;
-
-interface PluginHookOptions<M extends boolean> {
-  mutable?: M;
-  onError?: PluginHookErrorHandler;
-}
-
-export interface PluginProjectDefinition {
-  macros?: MacrosCollection;
-  tasks?: Record<string, RuniumTaskConstructor>;
-  actions?: Record<string, (payload: unknown) => void>;
-  triggers?: Record<string, RuniumTriggerConstructor<RuniumTriggerOptions>>;
-  validationSchema?: ProjectSchemaExtension;
-}
-
-export type PluginOptions = Record<string, unknown>;
-
-export interface PluginAppDefinition {
-  commands?: RuniumCommandConstructor[];
-}
-
-export interface PluginProjectHooksDefinition {
-  beforeConfigRead?(path: string): Promise<void>;
-  afterConfigRead?(content: string): Promise<string>;
-  afterConfigMacrosApply?(content: string): Promise<string>;
-  afterConfigParse?<T extends ProjectConfig>(config: T): Promise<T>;
-  beforeStart?(project: Project): Promise<void>;
-}
-
-export interface PluginAppHooksDefinition {
-  afterInit?(params: { profilePath: string }): Promise<void>;
-  beforeExit?(reason?: string): Promise<void>;
-  beforeCommandRun?(params: {
-    command: string;
-    args: unknown[];
-  }): Promise<void>;
-  afterCommandRun?(params: { command: string; args: unknown[] }): Promise<void>;
-}
-
-export interface PluginHooksDefinition {
-  app?: PluginAppHooksDefinition;
-  project?: PluginProjectHooksDefinition;
-}
-
-export interface Plugin {
-  name: string;
-  project?: PluginProjectDefinition;
-  options?: PluginOptions;
-  app?: PluginAppDefinition;
-  hooks?: PluginHooksDefinition;
-}
-
-@Service()
-export class PluginService {
-  /**
-   * Loaded plugins
-   */
-  private plugins: Map<string, Plugin> = new Map();
-
-  /**
-   * Validate plugin schema
-   * @private
-   */
-  private validator: ReturnType<typeof createValidator> =
-    createValidator(getPluginSchema());
-
-  constructor(@Inject() private outputService: OutputService) {}
-
-  /**
-   * Get all plugins
-   */
-  getAllPlugins(): Plugin[] {
-    return Array.from(this.plugins.values());
-  }
-
-  /**
-   * Get plugin by name
-   * @param name
-   */
-  getPluginByName(name: string): Plugin | undefined {
-    return this.plugins.get(name);
-  }
-
-  /**
-   * Load plugin
-   * @param path
-   * @param options
-   */
-  async loadPlugin(path: string, options?: PluginOptions): Promise<string> {
-    if (!path || !existsSync(path)) {
-      throw new RuniumError(
-        `Plugin file "${path}" does not exist`,
-        ErrorCode.PLUGIN_FILE_NOT_FOUND,
-        { path }
-      );
-    }
-
-    try {
-      const pluginModule = (await import(path)) as PluginModule;
-      const { default: getPlugin } = pluginModule;
-      if (!getPlugin || typeof getPlugin !== 'function') {
-        throw new RuniumError(
-          'Plugin module must have a default function',
-          ErrorCode.PLUGIN_INCORRECT_MODULE,
-          { path }
-        );
-      }
-      const plugin = getPlugin(options);
-
-      this.validate(plugin);
-
-      this.plugins.set(plugin.name, plugin);
-
-      return plugin.name;
-    } catch (error) {
-      if (isRuniumError(error)) {
-        throw error;
-      }
-      throw new RuniumError(
-        `Failed to load plugin "${path}"`,
-        ErrorCode.PLUGIN_LOAD_ERROR,
-        { path, original: error }
-      );
-    }
-  }
-
-  /**
-   * Unload plugin
-   * @param name
-   */
-  async unloadPlugin(name: string): Promise<boolean> {
-    return this.plugins.delete(name);
-  }
-
-  /**
-   * Resolve path
-   * @param path
-   * @param isFile
-   */
-  resolvePath(path: string, isFile: boolean = false): string {
-    try {
-      const resolvedPath = isFile ? resolve(path) : import.meta.resolve(path);
-      return resolvedPath.replace('file://', '');
-    } catch (error) {
-      throw new RuniumError(
-        `Failed to resolve plugin path "${path}"`,
-        ErrorCode.PLUGIN_PATH_RESOLVE_ERROR,
-        { path, original: error }
-      );
-    }
-  }
-
-  /**
-   * Run plugin hook
-   * @param name
-   * @param params
-   * @param options
-   */
-  async runHook<T, M extends boolean>(
-    name: PluginHookName,
-    params: T,
-    { mutable, onError }: PluginHookOptions<M> = {}
-  ): Promise<M extends true ? T : void> {
-    const plugins = this.getAllPlugins();
-
-    const [group, hookName] = name.split('.') as [
-      keyof PluginHooksDefinition,
-      keyof PluginHooksDefinition[keyof PluginHooksDefinition],
-    ];
-
-    for (const plugin of plugins) {
-      const hook = plugin.hooks?.[group]?.[hookName] as
-        | ((params: T) => Promise<T>)
-        | undefined;
-      if (hook) {
-        try {
-          if (!mutable) {
-            await hook(params);
-          } else {
-            params = (await hook(params)) ?? params;
-          }
-        } catch (ex) {
-          const error = new RuniumError(
-            `Failed to run "${plugin.name}.${name}" hook`,
-            ErrorCode.PLUGIN_HOOK_ERROR,
-            { plugin: plugin.name, hook: name, original: ex }
-          );
-          if (onError) {
-            onError(error);
-          } else {
-            this.outputService.error('Error: %s', error.message);
-            this.outputService.debug('Error details:', {
-              code: error.code,
-              payload: error.payload,
-            });
-          }
-        }
-      }
-    }
-
-    return (mutable ? params : undefined) as M extends true ? T : void;
-  }
-
-  /**
-   * Validate plugin
-   * @param plugin
-   */
-  private validate(plugin: Plugin): void {
-    const result = this.validator(plugin || {});
-    if (!result && this.validator.errors) {
-      const errorMessages = getErrorMessages(this.validator.errors);
-      throw new RuniumError(
-        'Incorrect plugin format',
-        ErrorCode.PLUGIN_INVALID,
-        { errors: errorMessages }
-      );
-    }
-  }
-}

package/src/services/profile.ts

@@ -1,199 +0,0 @@
-import { existsSync } from 'node:fs';
-import { mkdir } from 'node:fs/promises';
-import { join } from 'node:path';
-import { Inject, Service } from 'typedi';
-import { ConfigService, FileService } from '@services';
-
-export interface ProfilePlugin {
-  name: string;
-  path: string;
-  file?: boolean;
-  disabled?: boolean;
-  options?: Record<string, unknown>;
-}
-
-export interface ProfileProject {
-  name: string;
-  path: string;
-}
-
-const PLUGINS_FILE_NAME = 'plugins.json';
-const PROJECTS_FILE_NAME = 'projects.json';
-
-@Service()
-export class ProfileService {
-  private path: string = process.cwd();
-
-  private plugins: ProfilePlugin[] = [];
-
-  private projects: ProfileProject[] = [];
-
-  constructor(
-    @Inject() private configService: ConfigService,
-    @Inject() private fileService: FileService
-  ) {}
-
-  /**
-   * Initialize the profile service
-   */
-  async init(): Promise<void> {
-    this.path = this.configService.get('profile').path;
-    if (!existsSync(this.path)) {
-      await mkdir(this.path, { recursive: true });
-    }
-
-    await this.readPlugins();
-    await this.patchPlugins();
-    await this.readProjects();
-  }
-
-  /**
-   * Get plugins
-   */
-  getPlugins(): ProfilePlugin[] {
-    return this.plugins;
-  }
-
-  /**
-   * Get plugin by name
-   * @param name
-   */
-  getPluginByName(name: string): ProfilePlugin | undefined {
-    return this.plugins.find(p => p.name === name);
-  }
-
-  /**
-   * Add plugin
-   * @param plugin
-   */
-  async addPlugin(plugin: ProfilePlugin): Promise<void> {
-    this.plugins = this.plugins
-      .filter(p => p.name !== plugin.name)
-      .concat(plugin);
-    await this.writePlugins();
-  }
-
-  /**
-   * Update plugin
-   * @param name
-   */
-  async removePlugin(name: string): Promise<void> {
-    this.plugins = this.plugins.filter(plugin => plugin.name !== name);
-    await this.writePlugins();
-  }
-
-  /**
-   * Update plugin
-   * @param name
-   * @param data
-   */
-  async updatePlugin(
-    name: string,
-    data: Partial<Omit<ProfilePlugin, 'name'>>
-  ): Promise<void> {
-    const index = this.plugins.findIndex(plugin => plugin.name === name);
-    if (index !== -1) {
-      this.plugins[index] = {
-        ...this.plugins[index],
-        ...data,
-      };
-      await this.writePlugins();
-    }
-  }
-
-  /**
-   * Get projects
-   */
-  getProjects(): ProfileProject[] {
-    return this.projects;
-  }
-
-  /**
-   * Get project by name
-   * @param name
-   */
-  getProjectByName(name: string): ProfileProject | undefined {
-    return this.projects.find(p => p.name === name);
-  }
-
-  /**
-   * Add project
-   * @param project
-   */
-  async addProject(project: ProfileProject): Promise<void> {
-    this.projects = this.projects
-      .filter(p => p.name !== project.name)
-      .concat(project);
-    await this.writeProjects();
-  }
-
-  /**
-   * Remove project
-   * @param name
-   */
-  async removeProject(name: string): Promise<void> {
-    this.projects = this.projects.filter(p => p.name !== name);
-    await this.writeProjects();
-  }
-
-  /**
-   * Get path for a file
-   * @param parts
-   */
-  getPath(...parts: string[]): string {
-    return join(this.path, ...parts);
-  }
-
-  /**
-   * Read plugins from file
-   */
-  private async readPlugins(): Promise<void> {
-    this.plugins =
-      ((await this.fileService
-        .readJson(this.getPath(PLUGINS_FILE_NAME))
-        .catch(() => [])) as ProfilePlugin[]) || this.plugins;
-  }
-
-  /**
-   * Write plugins to file
-   */
-  private async writePlugins(): Promise<void> {
-    await this.fileService.writeJson(
-      this.getPath(PLUGINS_FILE_NAME),
-      this.plugins
-    );
-  }
-
-  /**
-   * Patch plugins
-   */
-  private async patchPlugins(): Promise<void> {
-    const pluginsConfig = this.configService.get('plugins');
-    for (const plugin of this.plugins) {
-      const config = pluginsConfig[plugin.name];
-      if (config) {
-        Object.assign(plugin, config);
-      }
-    }
-  }
-
-  /**
-   * Read projects from file
-   */
-  private async readProjects(): Promise<void> {
-    this.projects =
-      ((await this.fileService
-        .readJson(this.getPath(PROJECTS_FILE_NAME))
-        .catch(() => [])) as ProfileProject[]) || this.projects;
-  }
-
-  /**
-   * Write projects to file
-   */
-  private async writeProjects(): Promise<void> {
-    await this.fileService.writeJson(
-      this.getPath(PROJECTS_FILE_NAME),
-      this.projects
-    );
-  }
-}

package/src/services/project.ts

@@ -1,142 +0,0 @@
-import { existsSync } from 'node:fs';
-import { readFile } from 'node:fs/promises';
-import { resolve } from 'node:path';
-import { Inject, Service } from 'typedi';
-import { applyMacros, Project, ProjectConfig, RuniumError } from '@runium/core';
-import { ErrorCode } from '@constants';
-import { macros } from '@macros';
-import { PluginProjectDefinition, PluginService } from '@services';
-
-@Service()
-export class ProjectService {
-  constructor(@Inject() private pluginService: PluginService) {}
-
-  /**
-   * Init project
-   * @param path
-   */
-  async initProject(path: string): Promise<Project> {
-    await this.pluginService.runHook('project.beforeConfigRead', path);
-
-    let content = await this.readFile(path);
-    content = await this.pluginService.runHook(
-      'project.afterConfigRead',
-      content,
-      { mutable: true }
-    );
-    content = this.applyMacros(content);
-    content = await this.pluginService.runHook(
-      'project.afterConfigMacrosApply',
-      content,
-      { mutable: true }
-    );
-
-    let projectData = this.parseProjectContent(content, path);
-    projectData = await this.pluginService.runHook(
-      'project.afterConfigParse',
-      projectData,
-      { mutable: true }
-    );
-
-    const project = new Project(projectData);
-    return this.extendProjectWithPlugins(project);
-  }
-
-  /**
-   * Resolve path
-   * @param path
-   */
-  resolvePath(path: string): string {
-    return resolve(path);
-  }
-
-  /**
-   * Run hook
-   * @param args
-   */
-  runHook(
-    ...args: Parameters<PluginService['runHook']>
-  ): ReturnType<PluginService['runHook']> {
-    return this.pluginService.runHook(...args);
-  }
-
-  /**
-   * Read project file
-   * @param path
-   */
-  private async readFile(path: string): Promise<string> {
-    if (!existsSync(path)) {
-      throw new RuniumError(
-        `Project file "${path}" does not exist`,
-        ErrorCode.PROJECT_FILE_NOT_FOUND,
-        { path }
-      );
-    }
-    try {
-      return readFile(path, { encoding: 'utf-8' });
-    } catch (error) {
-      throw new RuniumError(
-        `Failed to read project file "${path}"`,
-        ErrorCode.PROJECT_FILE_CAN_NOT_READ,
-        { path, original: error }
-      );
-    }
-  }
-
-  /**
-   * Apply macros to text
-   * @param text
-   */
-  private applyMacros(text: string): string {
-    const plugins = this.pluginService.getAllPlugins();
-    const pluginMacros = plugins.reduce(
-      (acc, plugin) => ({ ...acc, ...(plugin.project?.macros || {}) }),
-      {}
-    );
-    return applyMacros(text, { ...pluginMacros, ...macros });
-  }
-
-  /**
-   * Parse project content
-   * @param content
-   * @param path
-   */
-  private parseProjectContent(content: string, path: string): ProjectConfig {
-    try {
-      return JSON.parse(content);
-    } catch (error) {
-      throw new RuniumError(
-        `Failed to parse project "${path}"`,
-        ErrorCode.PROJECT_JSON_PARSE_ERROR,
-        { path, original: error }
-      );
-    }
-  }
-
-  /**
-   * Extends the project with plugins
-   * @param project
-   */
-  private extendProjectWithPlugins(project: Project): Project {
-    const plugins = this.pluginService.getAllPlugins();
-
-    plugins.forEach(plugin => {
-      const { tasks, actions, triggers, validationSchema } = (plugin.project ||
-        {}) as PluginProjectDefinition;
-      Object.entries(actions || {}).forEach(([type, processor]) => {
-        project.registerAction(type, processor);
-      });
-      Object.entries(tasks || {}).forEach(([type, processor]) => {
-        project.registerTask(type, processor);
-      });
-      Object.entries(triggers || {}).forEach(([type, processor]) => {
-        project.registerTrigger(type, processor);
-      });
-      if (validationSchema) {
-        project.extendValidationSchema(validationSchema);
-      }
-    });
-
-    return project;
-  }
-}