@runium/types-core 0.0.7

package/index.d.ts

@@ -0,0 +1,414 @@
+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;
+    }
+
+    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 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/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@runium/types-core",
+  "version": "0.0.7",
+  "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"
+  ],
+  "devDependencies": {
+    "@types/node": "^22.18.0"
+  }
+}