@runium/core 0.0.9 → 0.1.1

package/.prettierrc.json

@@ -1,10 +0,0 @@
-{
-  "semi": true,
-  "trailingComma": "es5",
-  "singleQuote": true,
-  "printWidth": 80,
-  "tabWidth": 2,
-  "useTabs": false,
-  "endOfLine": "lf",
-  "arrowParens": "avoid"
-}

package/README.md

@@ -1 +0,0 @@
-# @runium/core

package/src/error.ts

@@ -1,22 +0,0 @@
-/**
- * Runium error class
- */
-export class RuniumError extends Error {
-  code: string;
-
-  payload: unknown;
-
-  constructor(message: string, code: string, payload: unknown = null) {
-    super(message);
-    this.code = code;
-    this.payload = payload;
-  }
-}
-
-/**
- * Checks if the given error is a RuniumError
- * @param error
- */
-export function isRuniumError(error: unknown): boolean {
-  return !!error && error instanceof RuniumError;
-}

package/src/file.ts

@@ -1,53 +0,0 @@
-import { readFile, writeFile } from 'node:fs/promises';
-import { RuniumError } from './error';
-
-export type JSONValue = string | number | boolean | JSONObject | JSONValue[];
-
-export interface JSONObject {
-  [x: string]: JSONValue;
-}
-
-/**
- * File error codes
- */
-export enum FileErrorCode {
-  READ_JSON = 'file-read-json',
-  WRITE_JSON = 'file-write-json',
-}
-
-/**
- * Reads a JSON file
- * @param path
- */
-export async function readJsonFile<T = JSONValue>(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}`,
-      FileErrorCode.READ_JSON,
-      { path, original: ex }
-    );
-  }
-}
-
-/**
- * Writes a JSON file
- * @param path
- * @param data
- */
-export async function writeJsonFile<T = JSONValue>(
-  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}`,
-      FileErrorCode.WRITE_JSON,
-      { path, data, original: ex }
-    );
-  }
-}

package/src/index.ts

@@ -1,8 +0,0 @@
-export * from './error';
-export * from './file';
-export * from './macros';
-export * from './project';
-export * from './project-config';
-export * from './project-schema';
-export * from './task';
-export * from './trigger';

package/src/macros.ts

@@ -1,91 +0,0 @@
-import { RuniumError } from './error';
-
-export type Macro = (...params: string[]) => string;
-
-export type MacrosCollection = Record<string, Macro>;
-
-const UNWRAP_MACROS_PATTERN = String.raw`"\$unwrap\((.*)\)"`;
-
-export enum MacrosErrorCode {
-  MACRO_APPLY_ERROR = 'macro-apply-error',
-}
-
-/**
- * Apply unwrap macro
- * @param value
- */
-function unwrap(value: string): string {
-  const unwrapRegex = new RegExp(UNWRAP_MACROS_PATTERN, 'g');
-
-  return value.replace(unwrapRegex, (match: string, value: string) => {
-    return value.trim();
-  });
-}
-
-/**
- * Apply macros to a text
- * @param text
- * @param macros
- */
-export function applyMacros(text: string, macros: MacrosCollection): string {
-  const macrosNames = Object.keys(macros);
-
-  const pattern = String.raw`\$(${macrosNames.join('|')})\(([^()]*(?:\([^()]*\)[^()]*)*)\)`;
-
-  const apply = (data: string): string => {
-    const macrosRegex = new RegExp(pattern, 'g');
-
-    let result = data;
-
-    let hasMacros = true;
-    while (hasMacros) {
-      hasMacros = false;
-      result = result.replace(
-        macrosRegex,
-        (match: string, type: string, args: string) => {
-          hasMacros = true;
-
-          const macroArgs: string[] = [];
-          let depth = 0;
-          let current = '';
-
-          for (const char of args) {
-            if (char === ',' && depth === 0) {
-              macroArgs.push(current.trim());
-              current = '';
-            } else {
-              if (char === '(') {
-                depth++;
-              }
-              if (char === ')') {
-                depth--;
-              }
-              current += char;
-            }
-          }
-          macroArgs.push(current.trim());
-
-          const values = macroArgs.map(arg => {
-            return arg ? apply(arg) : '';
-          });
-          try {
-            return macros[type](...values);
-          } catch (ex) {
-            throw new RuniumError(
-              `Can not apply macro "${type}"`,
-              MacrosErrorCode.MACRO_APPLY_ERROR,
-              { type, args: macroArgs, original: ex }
-            );
-          }
-        }
-      );
-    }
-
-    return result;
-  };
-
-  // process text
-  const processedText = macrosNames.length ? apply(text) : text;
-  // apply unwrap macros
-  return unwrap(processedText);
-}

package/src/project-config.ts

@@ -1,483 +0,0 @@
-import Ajv from 'ajv/dist/2020.js';
-import ajvKeywords from 'ajv-keywords';
-import { RuniumTaskState, TaskOptions } from './task';
-import { RuniumError } from './error';
-
-/**
- * Project task start mode
- */
-export enum ProjectTaskStartMode {
-  IMMEDIATE = 'immediate',
-  DEFERRED = 'deferred',
-  IGNORE = 'ignore',
-}
-
-/**
- * Project action type
- */
-export enum ProjectActionType {
-  EMIT_EVENT = 'emit-event',
-  START_TASK = 'start-task',
-  RESTART_TASK = 'restart-task',
-  STOP_TASK = 'stop-task',
-  STOP_PROJECT = 'stop-project',
-  ENABLE_TRIGGER = 'enable-trigger',
-  DISABLE_TRIGGER = 'disable-trigger',
-}
-
-/**
- * Project task state condition
- */
-export type ProjectTaskStateCondition =
-  | string
-  | boolean
-  | Partial<RuniumTaskState>
-  | ((state: RuniumTaskState) => boolean);
-
-/**
- * Project task handler
- */
-export interface ProjectTaskHandler {
-  condition: ProjectTaskStateCondition;
-  action: ProjectAction;
-}
-
-/**
- * Project task dependency
- */
-export interface ProjectTaskDependency {
-  taskId: string;
-  condition: ProjectTaskStateCondition;
-}
-
-/**
- * Project task type
- */
-export enum ProjectTaskType {
-  DEFAULT = 'default',
-}
-
-/**
- * Project task config
- */
-export interface ProjectTaskConfig<Options = unknown> {
-  id: string;
-  options: Options;
-  type?: ProjectTaskType | string;
-  name?: string;
-  mode?: ProjectTaskStartMode;
-  dependencies?: ProjectTaskDependency[];
-  handlers?: ProjectTaskHandler[];
-  restart?: ProjectTaskRestartPolicy;
-}
-
-/**
- * Project default task config
- */
-export interface ProjectDefaultTaskConfig
-  extends ProjectTaskConfig<TaskOptions> {
-  type?: ProjectTaskType.DEFAULT;
-}
-
-/**
- * Project action emit event
- */
-export interface ProjectActionEmitEvent {
-  type: ProjectActionType.EMIT_EVENT;
-  event: string;
-}
-
-/**
- * Project action process task
- */
-export interface ProjectActionProcessTask {
-  type:
-    | ProjectActionType.START_TASK
-    | ProjectActionType.RESTART_TASK
-    | ProjectActionType.STOP_TASK;
-  taskId: string;
-}
-
-/**
- * Project action stop project
- */
-export interface ProjectActionStopProject {
-  type: ProjectActionType.STOP_PROJECT;
-}
-
-/**
- * Project action toggle trigger
- */
-export interface ProjectActionToggleTrigger {
-  type: ProjectActionType.ENABLE_TRIGGER | ProjectActionType.DISABLE_TRIGGER;
-  triggerId: string;
-}
-
-/**
- * Project custom action
- */
-export interface ProjectCustomAction {
-  type: string;
-  payload?: unknown;
-}
-
-/**
- * Project action
- */
-export type ProjectAction =
-  | ProjectCustomAction
-  | ProjectActionEmitEvent
-  | ProjectActionProcessTask
-  | ProjectActionStopProject
-  | ProjectActionToggleTrigger;
-
-/**
- * Project trigger type
- */
-export enum ProjectTriggerType {
-  EVENT = 'event',
-  TIMEOUT = 'timeout',
-  INTERVAL = 'interval',
-}
-
-/**
- * Project trigger base
- */
-interface ProjectTriggerBase {
-  id: string;
-  type: ProjectTriggerType | string;
-  action: ProjectAction;
-  disabled?: boolean;
-}
-
-/**
- * Project trigger event
- */
-export interface ProjectTriggerEvent extends ProjectTriggerBase {
-  type: ProjectTriggerType.EVENT;
-  event: string;
-}
-
-/**
- * Project trigger interval
- */
-export interface ProjectTriggerInterval extends ProjectTriggerBase {
-  type: ProjectTriggerType.INTERVAL;
-  interval: number;
-}
-
-/**
- * Project trigger timeout
- */
-export interface ProjectTriggerTimeout extends ProjectTriggerBase {
-  type: ProjectTriggerType.TIMEOUT;
-  timeout: number;
-}
-
-/**
- * Project custom trigger
- */
-export interface ProjectCustomTrigger extends ProjectTriggerBase {
-  type: string;
-  payload?: unknown;
-}
-
-/**
- * Project trigger
- */
-export type ProjectTrigger =
-  | ProjectTriggerEvent
-  | ProjectTriggerInterval
-  | ProjectTriggerTimeout
-  | ProjectCustomTrigger;
-
-/**
- * Project task restart policy type
- */
-export enum ProjectTaskRestartPolicyType {
-  ALWAYS = 'always',
-  ON_FAILURE = 'on-failure',
-}
-
-/**
- * Project task restart policy always
- */
-export interface ProjectTaskRestartPolicyAlways {
-  policy: ProjectTaskRestartPolicyType.ALWAYS;
-  delay?: number;
-}
-
-/**
- * Project task restart policy on failure
- */
-export interface ProjectTaskRestartPolicyOnFailure {
-  policy: ProjectTaskRestartPolicyType.ON_FAILURE;
-  delay?: number;
-  maxRetries?: number;
-}
-
-/**
- * Project task restart policy
- */
-export type ProjectTaskRestartPolicy =
-  | ProjectTaskRestartPolicyAlways
-  | ProjectTaskRestartPolicyOnFailure;
-
-/**
- * Project config
- */
-export interface ProjectConfig {
-  id: string;
-  name?: string;
-  tasks: ProjectTaskConfig[];
-  triggers?: ProjectTrigger[];
-}
-
-/**
- * Project config error codes
- */
-export enum ProjectConfigErrorCode {
-  INCORRECT_DATA = 'project-config-incorrect-data',
-  TASKS_CIRCULAR_DEPENDENCY = 'project-config-tasks-circular-dependency',
-  TASK_NOT_EXISTS = 'project-config-task-not-exists',
-  TRIGGER_NOT_EXISTS = 'project-config-trigger-not-exists',
-}
-
-/**
- * Process task action types
- */
-const PROCESS_TASK_ACTION_TYPES = new Set<ProjectActionType>([
-  ProjectActionType.START_TASK,
-  ProjectActionType.RESTART_TASK,
-  ProjectActionType.STOP_TASK,
-]);
-
-/**
- * Toggle trigger action types
- */
-const TOGGLE_TRIGGER_ACTION_TYPES = new Set<ProjectActionType>([
-  ProjectActionType.ENABLE_TRIGGER,
-  ProjectActionType.DISABLE_TRIGGER,
-]);
-
-/**
- * Runium action types
- */
-const RUNIUM_ACTION_TYPES = new Set(Object.values(ProjectActionType));
-
-/**
- * Runium trigger types
- */
-const RUNIUM_TRIGGER_TYPES = new Set(Object.values(ProjectTriggerType));
-
-/**
- * Is process task action guard
- * @param action
- */
-export function isProcessTaskAction(
-  action: ProjectAction
-): action is ProjectActionProcessTask {
-  return PROCESS_TASK_ACTION_TYPES.has(action.type as ProjectActionType);
-}
-
-/**
- * Is toggle trigger action guard
- * @param action
- */
-export function isToggleTriggerAction(
-  action: ProjectAction
-): action is ProjectActionToggleTrigger {
-  return TOGGLE_TRIGGER_ACTION_TYPES.has(action.type as ProjectActionType);
-}
-
-/**
- * Is custom action guard
- * @param action
- */
-export function isCustomAction(
-  action: ProjectAction
-): action is ProjectCustomAction {
-  return !RUNIUM_ACTION_TYPES.has(action.type as ProjectActionType);
-}
-
-/**
- * Is custom trigger guard
- * @param trigger
- */
-export function isCustomTrigger(
-  trigger: ProjectTrigger
-): trigger is ProjectCustomTrigger {
-  return !RUNIUM_TRIGGER_TYPES.has(trigger.type as ProjectTriggerType);
-}
-
-const ajv = new Ajv({ allowUnionTypes: true, allErrors: true, verbose: true });
-ajvKeywords(ajv, ['uniqueItemProperties']);
-
-/**
- * Validate project schema
- * @param project
- * @param schema
- */
-function validateSchema(project: ProjectConfig, schema: object): void {
-  const validate = ajv.compile(schema || {});
-  const result = validate(project);
-  if (!result) {
-    throw new RuniumError(
-      'Incorrect project config data',
-      ProjectConfigErrorCode.INCORRECT_DATA,
-      {
-        errors: validate.errors,
-      }
-    );
-  }
-}
-
-/**
- * Detect cycles in dependencies
- * @param deps
- */
-function detectCycles(deps: Map<string, string[]>) {
-  const visited: Set<string> = new Set();
-  const stack: Set<string> = new Set();
-
-  const dfs = (node: string) => {
-    if (stack.has(node)) {
-      const cycle = [...stack, node].join(' -> ');
-      throw new RuniumError(
-        `Project config tasks circular dependency detected ${cycle}`,
-        ProjectConfigErrorCode.TASKS_CIRCULAR_DEPENDENCY,
-        {
-          task: node,
-          dependencies: [...stack],
-        }
-      );
-    }
-    if (visited.has(node)) return;
-
-    stack.add(node);
-    for (const neighbor of deps.get(node) || []) {
-      dfs(neighbor);
-    }
-    stack.delete(node);
-    visited.add(node);
-  };
-
-  for (const node of deps.keys()) {
-    if (!visited.has(node)) {
-      dfs(node);
-    }
-  }
-}
-
-/**
- * Validate existing elements
- * @param project
- */
-function validateExistingElements(project: ProjectConfig): void {
-  // task dependencies graph
-  const deps: Map<string, string[]> = new Map();
-
-  // task ids
-  const taskIds: Set<string> = new Set();
-  for (const task of project.tasks) {
-    taskIds.add(task.id);
-    deps.set(task.id, []);
-  }
-
-  const triggerIds: Set<string> = new Set(
-    project.triggers?.map(t => t.id) || []
-  );
-
-  // check every task dependencies, handler actions use existing task and existing triggers
-  for (const task of project.tasks) {
-    for (const dependency of task.dependencies || []) {
-      if (!taskIds.has(dependency.taskId)) {
-        throw new RuniumError(
-          `Task "${task.id}" depends on not existing task "${dependency.taskId}"`,
-          ProjectConfigErrorCode.TASK_NOT_EXISTS,
-          {
-            taskId: task.id,
-            dependency: { ...dependency },
-            scope: 'dependencies',
-          }
-        );
-      }
-      deps.get(dependency.taskId)!.push(task.id);
-    }
-
-    for (const handler of task.handlers || []) {
-      if (
-        isProcessTaskAction(handler.action) &&
-        !taskIds.has(handler.action.taskId)
-      ) {
-        throw new RuniumError(
-          `Task "${task.id}" handler action uses not existing task "${handler.action.taskId}"`,
-          ProjectConfigErrorCode.TASK_NOT_EXISTS,
-          {
-            taskId: task.id,
-            handler: { ...handler },
-            scope: 'handlers',
-          }
-        );
-      } else if (
-        isToggleTriggerAction(handler.action) &&
-        !triggerIds.has(handler.action.triggerId)
-      ) {
-        throw new RuniumError(
-          `Task "${task.id}" handler action uses not existing trigger "${handler.action.triggerId}"`,
-          ProjectConfigErrorCode.TRIGGER_NOT_EXISTS,
-          {
-            taskId: task.id,
-            handler: { ...handler },
-            scope: 'handlers',
-          }
-        );
-      }
-    }
-  }
-
-  // check project triggers use existing tasks and triggers
-  for (const trigger of project.triggers || []) {
-    if (
-      isProcessTaskAction(trigger.action) &&
-      !taskIds.has(trigger.action.taskId)
-    ) {
-      throw new RuniumError(
-        `Trigger "${trigger.id}" action uses not existing task "${trigger.action.taskId}"`,
-        ProjectConfigErrorCode.TASK_NOT_EXISTS,
-        {
-          trigger: { ...trigger },
-          scope: 'triggers',
-        }
-      );
-    } else if (
-      isToggleTriggerAction(trigger.action) &&
-      !triggerIds.has(trigger.action.triggerId)
-    ) {
-      throw new RuniumError(
-        `Trigger "${trigger.id}" action uses not existing trigger "${trigger.action.triggerId}"`,
-        ProjectConfigErrorCode.TRIGGER_NOT_EXISTS,
-        {
-          trigger: { ...trigger },
-          scope: 'triggers',
-        }
-      );
-    }
-  }
-
-  // detect circular and non unique dependencies
-  detectCycles(deps);
-}
-
-/**
- * Validate project
- * @param project
- * @param schema
- */
-export function validateProject(project: ProjectConfig, schema: object): void {
-  // validate schema
-  validateSchema(project, schema);
-
-  // validate existing elements
-  validateExistingElements(project);
-}