@runium/core 0.0.7 → 0.0.9

package/types/index.d.ts

@@ -0,0 +1,510 @@
+declare module '@runium/core' {
+  import { ChildProcessWithoutNullStreams } from 'node:child_process';
+  import { EventEmitter } from 'node:events';
+  import { WriteStream } from 'node:fs';
+
+  export function applyMacros(text: string, macros: MacrosCollection): string;
+
+  export class EventTrigger extends RuniumTrigger<EventTriggerOptions> {
+    constructor(
+      options: EventTriggerOptions,
+      project: RuniumTriggerProjectAccessible
+    );
+    enable(): void;
+    disable(): void;
+  }
+
+  export interface EventTriggerOptions extends RuniumTriggerOptions {
+    event: string;
+  }
+
+  export function extendProjectSchema(
+    schema: object,
+    extensions: ProjectSchemaExtension
+  ): object;
+
+  export enum FileErrorCode {
+    READ_JSON = 'file-read-json',
+    WRITE_JSON = 'file-write-json',
+  }
+
+  export function getProjectSchema(): object;
+
+  export const ID_REGEX: RegExp;
+
+  export class IntervalTrigger extends RuniumTrigger<IntervalTriggerOptions> {
+    constructor(
+      options: IntervalTriggerOptions,
+      project: RuniumTriggerProjectAccessible
+    );
+    enable(): void;
+    disable(): void;
+  }
+
+  export interface IntervalTriggerOptions extends RuniumTriggerOptions {
+    interval: number;
+  }
+
+  export function isCustomAction(
+    action: ProjectAction
+  ): action is ProjectCustomAction;
+
+  export function isCustomTrigger(
+    trigger: ProjectTrigger
+  ): trigger is ProjectCustomTrigger;
+
+  export function isProcessTaskAction(
+    action: ProjectAction
+  ): action is ProjectActionProcessTask;
+
+  export function isRuniumError(error: unknown): boolean;
+
+  export function isToggleTriggerAction(
+    action: ProjectAction
+  ): action is ProjectActionToggleTrigger;
+
+  export interface JSONObject {
+    [x: string]: JSONValue;
+  }
+
+  export type JSONValue = string | number | boolean | JSONObject | JSONValue[];
+
+  export type Macro = (...params: string[]) => string;
+
+  export type MacrosCollection = Record<string, Macro>;
+
+  export enum MacrosErrorCode {
+    MACRO_APPLY_ERROR = 'macro-apply-error',
+  }
+
+  export class Project extends EventEmitter {
+    constructor(config: ProjectConfig);
+    validate(): void;
+    getConfig(): ProjectConfig;
+    setConfig(config: ProjectConfig): void;
+    getState(): ProjectState;
+    start(): Promise<void>;
+    stop(reason?: string): Promise<void>;
+    extendValidationSchema(extensions: ProjectSchemaExtension): void;
+    registerAction(type: string, processor: RuniumActionProcessor): void;
+    registerTask(
+      type: string,
+      processor: RuniumTaskConstructor<unknown, any>
+    ): void;
+    registerTrigger(
+      type: string,
+      processor: RuniumTriggerConstructor<any>
+    ): void;
+    startTask(taskId: string): Promise<void>;
+    stopTask(taskId: string): Promise<void>;
+    restartTask(taskId: string): Promise<void>;
+    getTaskState<T extends RuniumTaskState = RuniumTaskState>(
+      taskId: string
+    ): T | null;
+    processAction(action: ProjectAction): void;
+    enableTrigger(triggerId: string): void;
+    disableTrigger(triggerId: string): void;
+  }
+
+  export type ProjectAction =
+    | ProjectCustomAction
+    | ProjectActionEmitEvent
+    | ProjectActionProcessTask
+    | ProjectActionStopProject
+    | ProjectActionToggleTrigger;
+
+  export interface ProjectActionEmitEvent {
+    type: ProjectActionType.EMIT_EVENT;
+    event: string;
+  }
+
+  export interface ProjectActionProcessTask {
+    type:
+      | ProjectActionType.START_TASK
+      | ProjectActionType.RESTART_TASK
+      | ProjectActionType.STOP_TASK;
+    taskId: string;
+  }
+
+  export interface ProjectActionStopProject {
+    type: ProjectActionType.STOP_PROJECT;
+  }
+
+  export interface ProjectActionToggleTrigger {
+    type: ProjectActionType.ENABLE_TRIGGER | ProjectActionType.DISABLE_TRIGGER;
+    triggerId: string;
+  }
+
+  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',
+  }
+
+  export interface ProjectConfig {
+    id: string;
+    name?: string;
+    tasks: ProjectTaskConfig[];
+    triggers?: ProjectTrigger[];
+  }
+
+  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',
+  }
+
+  export interface ProjectCustomAction {
+    type: string;
+    payload?: unknown;
+  }
+
+  export interface ProjectCustomTrigger extends ProjectTriggerBase {
+    type: string;
+    payload?: unknown;
+  }
+
+  export interface ProjectDefaultTaskConfig
+    extends ProjectTaskConfig<TaskOptions> {
+    type?: ProjectTaskType.DEFAULT;
+  }
+
+  export enum ProjectErrorCode {
+    ACTION_PROCESSOR_ALREADY_REGISTERED = 'project-action-processor-already-registered',
+    ACTION_PROCESSOR_INCORRECT = 'project-action-processor-incorrect',
+    TASK_PROCESSOR_NOT_FOUND = 'project-task-processor-not-found',
+    TASK_PROCESSOR_ALREADY_REGISTERED = 'project-task-processor-already-registered',
+    TASK_PROCESSOR_INCORRECT = 'project-task-processor-incorrect',
+    TRIGGER_PROCESSOR_ALREADY_REGISTERED = 'project-trigger-processor-already-registered',
+    TRIGGER_PROCESSOR_INCORRECT = 'project-trigger-processor-incorrect',
+  }
+
+  export enum ProjectEvent {
+    STATE_CHANGE = 'state-change',
+    START_TASK = 'start-task',
+    RESTART_TASK = 'restart-task',
+    STOP_TASK = 'stop-task',
+    PROCESS_ACTION = 'process-action',
+    ENABLE_TRIGGER = 'enable-trigger',
+    DISABLE_TRIGGER = 'disable-trigger',
+    TASK_STATE_CHANGE = 'task-state-change',
+    TASK_STDOUT = 'task-stdout',
+    TASK_STDERR = 'task-stderr',
+  }
+
+  export enum ProjectSchemaErrorCode {
+    ACTION_TYPE_ALREADY_USED = 'project-schema-action-type-already-used',
+    TASK_TYPE_ALREADY_USED = 'project-schema-task-type-already-used',
+    TRIGGER_TYPE_ALREADY_USED = 'project-schema-trigger-type-already-used',
+  }
+
+  export interface ProjectSchemaExtensionProject {
+    properties: unknown;
+    required?: string[];
+  }
+
+  export interface ProjectSchemaExtensionTask {
+    type: string;
+    options: unknown;
+  }
+
+  export interface ProjectSchemaExtensionAction {
+    type: string;
+    payload?: unknown;
+  }
+
+  export interface ProjectSchemaExtensionTrigger {
+    type: string;
+    payload?: unknown;
+  }
+
+  export interface ProjectSchemaExtension {
+    project?: {
+      properties: unknown;
+      required?: string[];
+    };
+    tasks?: Record<
+      string,
+      {
+        type: string;
+        options: unknown;
+      }
+    >;
+    definitions?: Record<string, unknown>;
+    actions?: Record<
+      string,
+      {
+        type: string;
+        payload?: unknown;
+      }
+    >;
+    triggers?: Record<
+      string,
+      {
+        type: string;
+        payload?: unknown;
+      }
+    >;
+  }
+
+  export interface ProjectState {
+    status: ProjectStatus;
+    timestamp: number;
+    reason?: string;
+  }
+
+  export enum ProjectStatus {
+    IDLE = 'idle',
+    STARTING = 'starting',
+    STARTED = 'started',
+    STOPPING = 'stopping',
+    STOPPED = 'stopped',
+  }
+
+  export interface ProjectTaskConfig<Options = unknown> {
+    id: string;
+    options: Options;
+    type?: ProjectTaskType | string;
+    name?: string;
+    mode?: ProjectTaskStartMode;
+    dependencies?: ProjectTaskDependency[];
+    handlers?: ProjectTaskHandler[];
+    restart?: ProjectTaskRestartPolicy;
+  }
+
+  export interface ProjectTaskDependency {
+    taskId: string;
+    condition: ProjectTaskStateCondition;
+  }
+
+  export interface ProjectTaskHandler {
+    condition: ProjectTaskStateCondition;
+    action: ProjectAction;
+  }
+
+  export type ProjectTaskRestartPolicy =
+    | ProjectTaskRestartPolicyAlways
+    | ProjectTaskRestartPolicyOnFailure;
+
+  export interface ProjectTaskRestartPolicyAlways {
+    policy: ProjectTaskRestartPolicyType.ALWAYS;
+    delay?: number;
+  }
+
+  export interface ProjectTaskRestartPolicyOnFailure {
+    policy: ProjectTaskRestartPolicyType.ON_FAILURE;
+    delay?: number;
+    maxRetries?: number;
+  }
+
+  export enum ProjectTaskRestartPolicyType {
+    ALWAYS = 'always',
+    ON_FAILURE = 'on-failure',
+  }
+
+  export enum ProjectTaskStartMode {
+    IMMEDIATE = 'immediate',
+    DEFERRED = 'deferred',
+    IGNORE = 'ignore',
+  }
+
+  export type ProjectTaskStateCondition =
+    | string
+    | boolean
+    | Partial<RuniumTaskState>
+    | ((state: RuniumTaskState) => boolean);
+
+  export enum ProjectTaskType {
+    DEFAULT = 'default',
+  }
+
+  export type ProjectTrigger =
+    | ProjectTriggerEvent
+    | ProjectTriggerInterval
+    | ProjectTriggerTimeout
+    | ProjectCustomTrigger;
+
+  interface ProjectTriggerBase {
+    id: string;
+    type: ProjectTriggerType | string;
+    action: ProjectAction;
+    disabled?: boolean;
+  }
+
+  export interface ProjectTriggerEvent extends ProjectTriggerBase {
+    type: ProjectTriggerType.EVENT;
+    event: string;
+  }
+
+  export interface ProjectTriggerInterval extends ProjectTriggerBase {
+    type: ProjectTriggerType.INTERVAL;
+    interval: number;
+  }
+
+  export interface ProjectTriggerTimeout extends ProjectTriggerBase {
+    type: ProjectTriggerType.TIMEOUT;
+    timeout: number;
+  }
+
+  export enum ProjectTriggerType {
+    EVENT = 'event',
+    TIMEOUT = 'timeout',
+    INTERVAL = 'interval',
+  }
+
+  export function readJsonFile<T = JSONValue>(path: string): Promise<T>;
+
+  type RuniumActionProcessor = (payload: unknown) => void;
+
+  export class RuniumError extends Error {
+    code: string;
+    payload: unknown;
+    constructor(message: string, code: string, payload?: unknown);
+  }
+
+  export abstract class RuniumTask<
+    Options = unknown,
+    State = RuniumTaskState,
+  > extends EventEmitter {
+    protected options: Options;
+    protected constructor(options: Options);
+    abstract getOptions(): Options;
+    abstract getState(): State;
+    abstract start(): Promise<void>;
+    abstract stop(reason?: string): Promise<void>;
+    abstract restart(): Promise<void>;
+  }
+
+  export type RuniumTaskConstructor<
+    Options = unknown,
+    State extends RuniumTaskState = RuniumTaskState,
+  > = new (options: any) => RuniumTask<Options, State>;
+
+  export interface RuniumTaskState {
+    status: TaskStatus;
+    timestamp: number;
+    iteration: number;
+    exitCode?: number;
+    error?: Error;
+    reason?: string;
+  }
+
+  export abstract class RuniumTrigger<Options extends RuniumTriggerOptions> {
+    protected project: RuniumTriggerProjectAccessible;
+    protected id: string;
+    protected action: ProjectAction;
+    protected disabled: boolean;
+    constructor(options: Options, project: RuniumTriggerProjectAccessible);
+    abstract enable(): void;
+    abstract disable(): void;
+    getId(): string;
+    isDisabled(): boolean;
+  }
+
+  export type RuniumTriggerConstructor<Options extends RuniumTriggerOptions> =
+    new (
+      options: Options,
+      project: RuniumTriggerProjectAccessible
+    ) => RuniumTrigger<Options>;
+
+  export interface RuniumTriggerOptions {
+    id: string;
+    action: ProjectAction;
+    disabled?: boolean;
+  }
+
+  export interface RuniumTriggerProjectAccessible {
+    processAction(action: ProjectAction): void;
+    on: NodeJS.EventEmitter['on'];
+    off: NodeJS.EventEmitter['off'];
+  }
+
+  export const SILENT_EXIT_CODE = -1;
+
+  export class Task extends RuniumTask<TaskOptions, TaskState> {
+    protected readonly options: TaskOptions;
+    protected state: TaskState;
+    protected process: ChildProcessWithoutNullStreams | null;
+    protected stdoutStream: WriteStream | null;
+    protected stderrStream: WriteStream | null;
+    protected ttlTimer: NodeJS.Timeout | null;
+    constructor(options: TaskOptions);
+    getState(): TaskState;
+    getOptions(): TaskOptions;
+    protected canStart(): boolean;
+    start(): Promise<void>;
+    protected canStop(): boolean;
+    stop(reason?: string): Promise<void>;
+    restart(): Promise<void>;
+    protected updateState(state: Partial<TaskState>): void;
+    protected initLogStreams(): Promise<void>;
+    protected setTTLTimer(): void;
+    protected addProcessListeners(): void;
+    protected onStdOutData(data: Buffer): void;
+    protected onStdErrData(data: Buffer): void;
+    protected onExit(code: number | null): void;
+    protected onError(error: Error): void;
+    protected cleanup(): void;
+  }
+
+  export enum TaskEvent {
+    STATE_CHANGE = 'state-change',
+    STDOUT = 'stdout',
+    STDERR = 'stderr',
+  }
+
+  export interface TaskOptions {
+    command: string;
+    arguments?: string[];
+    shell?: boolean;
+    stopSignal?: string;
+    cwd?: string;
+    env?: {
+      [key: string]: string | number | boolean;
+    };
+    ttl?: number;
+    log?: {
+      stdout?: string | null;
+      stderr?: string | null;
+    };
+  }
+
+  export interface TaskState extends RuniumTaskState {
+    pid: number;
+  }
+
+  export enum TaskStatus {
+    IDLE = 'idle',
+    STARTING = 'starting',
+    STARTED = 'started',
+    COMPLETED = 'completed',
+    FAILED = 'failed',
+    STOPPING = 'stopping',
+    STOPPED = 'stopped',
+  }
+
+  export class TimeoutTrigger extends RuniumTrigger<TimeoutTriggerOptions> {
+    constructor(
+      options: TimeoutTriggerOptions,
+      project: RuniumTriggerProjectAccessible
+    );
+    enable(): void;
+    disable(): void;
+  }
+
+  export interface TimeoutTriggerOptions extends RuniumTriggerOptions {
+    timeout: number;
+  }
+
+  export function validateProject(project: ProjectConfig, schema: object): void;
+
+  export function writeJsonFile<T = JSONValue>(
+    path: string,
+    data: T
+  ): Promise<void>;
+}

package/types/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@runium/types-core",
+  "version": "0.0.0",
+  "description": "TypeScript type definitions for Runium Core",
+  "author": "TheBeastApp",
+  "license": "MIT",
+  "type": "module",
+  "main": "index.d.ts",
+  "types": "index.d.ts",
+  "files": [
+    "index.d.ts"
+  ],
+  "keywords": [
+    "runium",
+    "core",
+    "types",
+    "typescript"
+  ],
+  "dependencies": {
+    "@types/node": "^22.18.0"
+  }
+}

package/vite.config.ts

@@ -0,0 +1,123 @@
+import { resolve } from 'node:path';
+import { writeFileSync, cpSync, readFileSync } from 'node:fs';
+import { defineConfig, UserConfig } from 'vite';
+import dts from 'vite-plugin-dts';
+import { externalizeDeps } from 'vite-plugin-externalize-deps';
+import { terser } from 'rollup-plugin-terser';
+
+export default defineConfig({
+  base: './',
+  plugins: [
+    externalizeDeps(),
+    dts({
+      rollupTypes: true,
+      insertTypesEntry: true,
+      outDir: 'dist/core',
+      strictOutput: true,
+      beforeWriteFile: (filePath, content) => {
+        const replacedContent = removePrivateMembers(content);
+        return {
+          filePath,
+          content: replacedContent,
+        };
+      },
+    }),
+    afterBuildPlugin(),
+  ],
+  build: {
+    target: 'es2022',
+    outDir: 'dist/core',
+    emptyOutDir: true,
+    sourcemap: false,
+    rollupOptions: {
+      plugins: [terser({ compress: true, module: true })],
+    },
+    lib: {
+      entry: resolve(__dirname, 'src/index.ts'),
+      formats: ['es'],
+      fileName: 'index',
+    },
+  },
+} satisfies UserConfig);
+
+function afterBuildPlugin() {
+  const processPackageJson = () => {
+    let packageJson = JSON.parse(
+      readFileSync(resolve(__dirname, 'package.json'), 'utf-8')
+    );
+
+    const { dependencies } = packageJson;
+
+    delete packageJson.dependencies;
+    delete packageJson.devDependencies;
+    delete packageJson.scripts;
+
+    packageJson = Object.assign(packageJson, {
+      main: './index.js',
+      module: './index.js',
+      files: ['index.js'],
+      exports: {
+        '.': {
+          import: './index.js',
+        },
+      },
+      dependencies,
+    });
+
+    writeFileSync(
+      resolve(__dirname, 'dist', 'core', 'package.json'),
+      JSON.stringify(packageJson, null, 2)
+    );
+  };
+
+  const processTypes = () => {
+    // Copy types folder to dist
+    cpSync(resolve(__dirname, 'types'), resolve(__dirname, 'dist', 'types'), {
+      recursive: true,
+    });
+
+    // Read core package version
+    const corePackageJson = JSON.parse(
+      readFileSync(resolve(__dirname, 'package.json'), 'utf-8')
+    );
+    const coreVersion = corePackageJson.version;
+
+    // Update types package.json version
+    const typesPackageJsonPath = resolve(
+      __dirname,
+      'dist',
+      'types',
+      'package.json'
+    );
+    const typesPackageJson = JSON.parse(
+      readFileSync(typesPackageJsonPath, 'utf-8')
+    );
+    typesPackageJson.version = coreVersion;
+
+    writeFileSync(
+      typesPackageJsonPath,
+      JSON.stringify(typesPackageJson, null, 2)
+    );
+  };
+
+  return {
+    name: 'after-build',
+    buildStart() {},
+    buildEnd() {},
+    closeBundle() {
+      processPackageJson();
+      processTypes();
+    },
+  };
+}
+
+function removePrivateMembers(content) {
+  const result = [];
+  content.split('\n').forEach(str => {
+    const isPrivate = str.includes('private ');
+    if (!isPrivate) {
+      result.push(str);
+    }
+  });
+  return result.join('\n');
+}