change files structure

server/src/core/di/env.ts

@@ -0,0 +1,45 @@
+import { reflection } from "first-di";
+
+@reflection
+export class IEnv{
+    rootFolder!: string; 
+    constructor(){
+        
+    }
+    toStringEnv(){
+        return ''
+    }
+    static env(){
+        return ''
+    }
+}
+
+@reflection
+export class DevEnv implements IEnv {
+    rootFolder:string;
+    constructor(rootFolder:string){
+        this.rootFolder = rootFolder
+    }
+    toStringEnv(): string {
+       return DevEnv.env()
+    }
+    static env(){
+        return 'DevEnv'
+
+    }
+}
+
+@reflection
+export class UnitTestEnv implements IEnv{
+    rootFolder:string;
+    constructor(rootFolder:string){
+        this.rootFolder = rootFolder
+    }
+    toStringEnv(): string {
+        return UnitTestEnv.env()
+    }
+    static env(){
+        return 'UnitTestEnv'
+
+    }
+}

server/src/core/di/register_di.ts

@@ -0,0 +1,48 @@
+import { override } from "first-di";
+import { DevEnv, IEnv , UnitTestEnv } from "./env.js";
+import { MetaDataFileManagerModel } from "../model/meta_data_file_manager_model.js";
+ 
+export default function locator(env: IEnv){
+  envRegister(env);
+  registerRepository(env);
+  registerController(env);
+  registerService(env);
+  override(MetaDataFileManagerModel, MetaDataFileManagerModel)
+}
+const envRegister = (env: IEnv) => {
+  switch (env.toStringEnv()) {
+    case UnitTestEnv.env():
+      override(IEnv, UnitTestEnv);
+      return;
+    case "DevEnv":
+      override(IEnv, DevEnv);
+      return;
+  }
+};
+const registerRepository = (env: IEnv) => {
+  switch (env.toStringEnv()) {
+    case UnitTestEnv.env():
+      override(IEnv, UnitTestEnv);
+
+      return;
+    case DevEnv.env():
+      override(IEnv, DevEnv);
+      return;
+  }
+};
+const registerController = (env: IEnv) => {
+  switch (env.toStringEnv()) {
+    case UnitTestEnv.env():
+      return;
+    case DevEnv.env():
+      return;
+  }
+};
+const registerService = (env: IEnv) => {
+  switch (env.toStringEnv()) {
+    case UnitTestEnv.env():
+      return;
+    case DevEnv.env():
+      return;
+  }
+};

server/src/core/helper/cancelable_promise.ts

@@ -0,0 +1,248 @@
+const toStringTag: typeof Symbol.toStringTag =
+  typeof Symbol !== 'undefined' ? Symbol.toStringTag : ('@@toStringTag' as any);
+
+class CancelablePromiseInternal<T = any> {
+  #internals: Internals;
+  #promise: Promise<T>;
+
+  [toStringTag] = 'CancelablePromise';
+
+  constructor({
+    executor = () => {},
+    internals = defaultInternals(),
+    promise = new Promise<T>((resolve, reject) =>
+      executor(resolve, reject, (onCancel) => {
+        internals.onCancelList.push(onCancel);
+      })
+    ),
+  }: {
+    executor?: (
+      resolve: (value: T | PromiseLike<T>) => void,
+      reject: (reason?: any) => void,
+      onCancel: (cancelHandler: () => void) => void
+    ) => void;
+    internals?: Internals;
+    promise?: Promise<T>;
+  }) {
+    this.cancel = this.cancel.bind(this);
+    this.#internals = internals;
+    this.#promise =
+      promise ||
+      new Promise<T>((resolve, reject) =>
+        executor(resolve, reject, (onCancel) => {
+          internals.onCancelList.push(onCancel);
+        })
+      );
+  }
+
+  then<TResult1 = T, TResult2 = never>(
+    onfulfilled?:
+      | ((
+          value: T
+        ) => TResult1 | PromiseLike<TResult1> | CancelablePromise<TResult1>)
+      | undefined
+      | null,
+    onrejected?:
+      | ((
+          reason: any
+        ) => TResult2 | PromiseLike<TResult2> | CancelablePromise<TResult2>)
+      | undefined
+      | null
+  ): CancelablePromise<TResult1 | TResult2> {
+    return makeCancelable<TResult1 | TResult2>(
+      this.#promise.then(
+        createCallback(onfulfilled, this.#internals),
+        createCallback(onrejected, this.#internals)
+      ),
+      this.#internals
+    );
+  }
+
+  catch<TResult = never>(
+    onrejected?:
+      | ((
+          reason: any
+        ) => TResult | PromiseLike<TResult> | CancelablePromise<TResult>)
+      | undefined
+      | null
+  ): CancelablePromise<T | TResult> {
+    return makeCancelable<T | TResult>(
+      this.#promise.catch(createCallback(onrejected, this.#internals)),
+      this.#internals
+    );
+  }
+
+  finally(
+    onfinally?: (() => void) | undefined | null,
+    runWhenCanceled?: boolean
+  ): CancelablePromise<T> {
+    if (runWhenCanceled) {
+      this.#internals.onCancelList.push(onfinally);
+    }
+    return makeCancelable<T>(
+      this.#promise.finally(
+        createCallback(() => {
+          if (onfinally) {
+            if (runWhenCanceled) {
+              this.#internals.onCancelList =
+                this.#internals.onCancelList.filter(
+                  (callback) => callback !== onfinally
+                );
+            }
+            return onfinally();
+          }
+        }, this.#internals)
+      ),
+      this.#internals
+    );
+  }
+
+  cancel(): void {
+    this.#internals.isCanceled = true;
+    const callbacks = this.#internals.onCancelList;
+    this.#internals.onCancelList = [];
+    for (const callback of callbacks) {
+      if (typeof callback === 'function') {
+        try {
+          callback();
+        } catch (err) {
+          console.error(err);
+        }
+      }
+    }
+  }
+
+  isCanceled(): boolean {
+    return this.#internals.isCanceled === true;
+  }
+}
+
+export class CancelablePromise<T = any> extends CancelablePromiseInternal<T> {
+  static all = function all(iterable: any) {
+    return makeAllCancelable(iterable, Promise.all(iterable));
+  } as CancelablePromiseOverloads['all'];
+
+  static allSettled = function allSettled(iterable: any) {
+    return makeAllCancelable(iterable, Promise.allSettled(iterable));
+  } as CancelablePromiseOverloads['allSettled'];
+
+  static any = function any(iterable: any) {
+    return makeAllCancelable(iterable, Promise.any(iterable));
+  } as CancelablePromiseOverloads['any'];
+
+  static race = function race(iterable) {
+    return makeAllCancelable(iterable, Promise.race(iterable));
+  } as CancelablePromiseOverloads['race'];
+
+  static resolve = function resolve(value) {
+    return cancelable(Promise.resolve(value));
+  } as CancelablePromiseOverloads['resolve'];
+
+  static reject = function reject(reason) {
+    return cancelable(Promise.reject(reason));
+  } as CancelablePromiseOverloads['reject'];
+
+  static isCancelable = isCancelablePromise;
+
+  constructor(
+    executor: (
+      resolve: (value: T | PromiseLike<T>) => void,
+      reject: (reason?: any) => void,
+      onCancel: (cancelHandler: () => void) => void
+    ) => void
+  ) {
+    super({ executor });
+  }
+}
+
+export default CancelablePromise;
+
+export function cancelable<T = any>(promise: Promise<T>): CancelablePromise<T> {
+  return makeCancelable(promise, defaultInternals());
+}
+
+export function isCancelablePromise(promise: any): boolean {
+  return (
+    promise instanceof CancelablePromise ||
+    promise instanceof CancelablePromiseInternal
+  );
+}
+
+function createCallback(onResult: any, internals: Internals):any {
+  if (onResult) {
+    return (arg?: any) => {
+      if (!internals.isCanceled) {
+        const result = onResult(arg);
+        if (isCancelablePromise(result)) {
+          internals.onCancelList.push(result.cancel);
+        }
+        return result;
+      }
+      return arg;
+    };
+  }
+}
+
+function makeCancelable<T>(promise: Promise<T>, internals: Internals) {
+  return new CancelablePromiseInternal<T>({
+    internals,
+    promise,
+  }) as CancelablePromise<T>;
+}
+
+function makeAllCancelable(iterable: any, promise: Promise<any>) {
+  const internals = defaultInternals();
+  internals.onCancelList.push(() => {
+    for (const resolvable of iterable) {
+      if (isCancelablePromise(resolvable)) {
+        resolvable.cancel();
+      }
+    }
+  });
+  return new CancelablePromiseInternal({ internals, promise });
+}
+
+function defaultInternals(): Internals {
+  return { isCanceled: false, onCancelList: [] };
+}
+
+interface Internals {
+  isCanceled: boolean;
+  onCancelList: any[];
+}
+
+interface CancelablePromiseOverloads {
+  all<T extends readonly unknown[] | []>(
+    values: T
+  ): CancelablePromise<{ -readonly [P in keyof T]: Awaited<T[P]> }>;
+
+  allSettled<T extends readonly unknown[] | []>(
+    values: T
+  ): CancelablePromise<{
+    -readonly [P in keyof T]: PromiseSettledResult<Awaited<T[P]>>;
+  }>;
+
+  allSettled<T>(
+    values: Iterable<T | PromiseLike<T> | CancelablePromise<T>>
+  ): CancelablePromise<PromiseSettledResult<Awaited<T>>[]>;
+
+  any<T extends readonly unknown[] | []>(
+    values: T
+  ): CancelablePromise<Awaited<T[number]>>;
+
+  any<T>(
+    values: Iterable<T | PromiseLike<T> | CancelablePromise<T>>
+  ): CancelablePromise<Awaited<T>>;
+
+  race<T extends readonly unknown[] | []>(
+    values: T
+  ): CancelablePromise<Awaited<T[number]>>;
+
+  resolve(): CancelablePromise<void>;
+
+  resolve<T>(
+    value: T | PromiseLike<T> | CancelablePromise<T>
+  ): CancelablePromise<T>;
+
+  reject<T = never>(reason?: any): CancelablePromise<T>;
+}

server/src/core/helper/delay.ts

@@ -0,0 +1,3 @@
+export function delay(ms: number) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

server/src/core/helper/result.ts

@@ -0,0 +1,533 @@
+/* eslint-disable @typescript-eslint/ban-types */
+/* eslint-disable @typescript-eslint/no-unnecessary-type-constraint */
+/* eslint-disable @typescript-eslint/no-namespace */
+ 
+
+function isAsyncFn(fn: Function) {
+  return fn.constructor.name === "AsyncFunction";
+}
+
+function isResult(value: unknown): value is Result<any, any, any> {
+  return value instanceof Ok || value instanceof Err;
+}
+
+interface SyncThenable {
+  isSync: true;
+  then<Fn extends () => Promise<any>>(cb: Fn): ReturnType<Fn>;
+  then<Fn extends () => any>(cb: Fn): SyncThenable;
+}
+
+ 
+function syncThenable(): SyncThenable {
+  function then<Fn extends () => Promise<any>>(cb: Fn): ReturnType<Fn>;
+  function then<Fn extends () => any>(cb: Fn): SyncThenable;
+  function then(cb: any) {
+    const result = cb();
+    if (result instanceof Promise) {
+      return result;
+    }
+
+    return syncThenable();
+  }
+
+  return {
+    isSync: true,
+    then,
+  };
+}
+
+function forEachValueThunkOrPromise<T>(
+  items: unknown[],
+  execFn: (value: T) => boolean,
+  foldFn: () => unknown
+) {
+  let shouldBreak = false;
+
+  const result: any = items.reduce((prev: { then: Function }, valueOrThunk) => {
+    return prev.then(() => {
+      if (shouldBreak) {
+        return null;
+      }
+
+      function run(value: T) {
+        const isSuccess = execFn(value);
+        if (!isSuccess) {
+          shouldBreak = true;
+        }
+      }
+
+      const valueOrPromise =
+        typeof valueOrThunk === "function" ? valueOrThunk() : valueOrThunk;
+
+      if (valueOrPromise instanceof Promise) {
+        return valueOrPromise.then(run);
+      }
+
+      return run(valueOrPromise);
+    });
+  }, syncThenable());
+
+  if ((result as SyncThenable).isSync) {
+    return foldFn();
+  }
+
+  return result.then(() => {
+    return foldFn();
+  });
+}
+
+export type Result<
+  ErrorType,
+  OkType,
+  RollbackFn extends RollbackFunction = any
+> = Ok<ErrorType, OkType, RollbackFn> | Err<ErrorType, OkType, RollbackFn>;
+
+interface IResult<ErrorType, OkType> {
+  isSuccess(): this is Ok<ErrorType, OkType, any>;
+
+  isFailure(): this is Err<ErrorType, OkType, any>;
+
+  getOrNull(): OkType | null;
+
+  toString(): string;
+
+  inspect(): string;
+
+  fold<R>(
+    onSuccess: (value: OkType) => R,
+    onFailure: (error: ErrorType) => R
+  ): R;
+  fold<R>(
+    onSuccess: (value: OkType) => Promise<R>,
+    onFailure: (error: ErrorType) => Promise<R>
+  ): Promise<R>;
+
+  getOrDefault(defaultValue: OkType): OkType;
+
+  getOrElse(onFailure: (error: ErrorType) => OkType): OkType;
+  getOrElse(onFailure: (error: ErrorType) => Promise<OkType>): Promise<OkType>;
+
+  getOrThrow(): OkType;
+
+  map<T>(
+    fn: (value: OkType) => Promise<T>
+  ): Promise<
+    JoinErrorTypes<
+      ErrorType,
+      T extends Result<any, any, any> ? T : Result<Error, T, any>
+    >
+  >;
+  map<T>(
+    fn: (value: OkType) => T
+  ): JoinErrorTypes<
+    ErrorType,
+    T extends Result<any, any, any> ? T : Result<Error, T, any>
+  >;
+
+  rollback(): Result<Error, void> | Promise<Result<Error, void>>;
+}
+
+type InferErrorType<T extends Result<any, any, any>> = T extends Result<
+  infer Errortype,
+  any,
+  any
+>
+  ? Errortype
+  : never;
+
+type InferOkType<T extends Result<any, any, any>> = T extends Result<
+  any,
+  infer OkType,
+  any
+>
+  ? OkType
+  : never;
+
+type JoinErrorTypes<ErrorType, B extends Result<any, any, any>> = Result<
+  ErrorType | InferErrorType<B>,
+  InferOkType<B>,
+  any
+>;
+
+type ExtractErrorTypes<Tuple extends any[]> = {
+  [Index in keyof Tuple]: Tuple[Index] extends Result<any, any, any>
+    ? InferErrorType<Tuple[Index]>
+    : never;
+}[number];
+
+type MapResultTupleToOkTypeTuple<Tuple extends any[]> = {
+  [Index in keyof Tuple]: Tuple[Index] extends Result<any, any, any>
+    ? InferOkType<Tuple[Index]>
+    : never;
+};
+
+type RollbackFunction = (() => void) | (() => Promise<void>);
+
+type HasAsyncRollbackFunction<T extends any[]> = {
+  [Index in keyof T]: T[Index] extends () => Promise<infer U> | infer U
+    ? U extends Result<any, any, () => Promise<void>>
+      ? true
+      : false
+    : false;
+}[number] extends false
+  ? false
+  : true;
+
+type UnwrapThunks<T extends any[]> = {
+  [Index in keyof T]: T[Index] extends () => Promise<infer U>
+    ? U
+    : T[Index] extends () => infer U
+    ? U
+    : T[Index];
+};
+
+type HasAsyncThunk<T extends any[]> = {
+  [Index in keyof T]: T[Index] extends () => Promise<any> ? true : false;
+}[number] extends false
+  ? false
+  : true;
+
+type PromiseReturnType<T extends (...args: any) => any> = T extends (
+  ...args: any
+) => Promise<infer U>
+  ? U
+  : never;
+
+export namespace Result {
+  export function ok<
+    ErrorType extends unknown,
+    OkType,
+    RollbackFn extends RollbackFunction = any
+  >(
+    value?: OkType,
+    rollbackFn?: RollbackFn
+  ): Result<ErrorType, OkType, RollbackFn> {
+    return new Ok<ErrorType, OkType, RollbackFn>(
+      value || null!,
+      rollbackFn
+    ) as any;
+  }
+
+  export function error<
+    ErrorType extends unknown,
+    OkType extends unknown,
+    RollbackFn extends RollbackFunction = any
+  >(
+    error: ErrorType,
+    rollbackFn?: RollbackFn
+  ): Result<ErrorType, OkType, RollbackFn> {
+    return new Err<ErrorType, OkType, RollbackFn>(error, rollbackFn);
+  }
+
+  type SafeReturnType<E, T> = T extends Result<any, any, any>
+    ? Result<E | InferErrorType<T>, InferOkType<T>, never>
+    : Result<E, T, never>;
+
+  export function safe<T>(
+    fn: () => Promise<T>
+  ): Promise<SafeReturnType<Error, T>>;
+  export function safe<T>(fn: () => T): SafeReturnType<Error, T>;
+  export function safe<ErrorType, T>(
+    err: ErrorType | (new (...args: any[]) => ErrorType),
+    fn: () => Promise<T>
+  ): Promise<SafeReturnType<ErrorType, T>>;
+  export function safe<ErrorType, T>(
+    err: ErrorType | (new (...args: any[]) => ErrorType),
+    fn: () => T
+  ): SafeReturnType<ErrorType, T>;
+  export function safe(errOrFn: any, fn?: any) {
+    const hasCustomError = fn !== undefined;
+
+    const execute = hasCustomError ? fn : errOrFn;
+
+    function getError(caughtError: Error) {
+      if (!hasCustomError) {
+        return caughtError;
+      }
+
+      if (typeof errOrFn === "function") {
+        return new errOrFn(caughtError);
+      }
+
+      return errOrFn;
+    }
+
+    try {
+      const resultOrPromise = execute();
+
+      if (resultOrPromise instanceof Promise) {
+        return resultOrPromise
+          .then((okValue) => {
+            return isResult(okValue) ? okValue : Result.ok(okValue);
+          })
+          .catch((caughtError) => error(getError(caughtError)));
+      }
+
+      return isResult(resultOrPromise)
+        ? resultOrPromise
+        : Result.ok(resultOrPromise);
+    } catch (caughtError) {
+      return error(getError(caughtError as Error));
+    }
+  }
+
+  type CombineResult<
+    T extends (unknown | (() => unknown) | (() => Promise<unknown>))[]
+  > = Result<
+    ExtractErrorTypes<UnwrapThunks<T>>,
+    MapResultTupleToOkTypeTuple<UnwrapThunks<T>>,
+    HasAsyncRollbackFunction<T> extends true ? () => Promise<void> : () => void
+  >;
+
+  export function combine<
+    T extends (unknown | (() => unknown) | (() => Promise<unknown>))[]
+  >(
+    ...items: T
+  ): HasAsyncThunk<T> extends true
+    ? Promise<CombineResult<T>>
+    : CombineResult<T> {
+    if (!items.length) {
+      throw new Error("Expected at least 1 argument");
+    }
+
+    const values: unknown[] = [];
+    const rollbacks: RollbackFunction[] = [];
+    let error: Err<unknown, unknown, any> | null = null;
+
+    function rollback() {
+      const reversedRollbacks = rollbacks.reverse();
+      const wrappedRollbackFns = reversedRollbacks.map((fn) => Result.wrap(fn));
+
+      let error: Err<unknown, unknown, any> | null = null;
+
+      return forEachValueThunkOrPromise(
+        wrappedRollbackFns,
+        (result: Result<unknown, unknown>) => {
+          if (result.isFailure()) {
+            error = Result.error<unknown, unknown, any>(result.error) as any;
+            return false;
+          }
+
+          return true;
+        },
+        () => error || ok()
+      );
+    }
+
+    return forEachValueThunkOrPromise(
+      items,
+      (result: Result<unknown, unknown>) => {
+        if (result.isFailure()) {
+          error = Result.error<unknown, unknown>(result.error, rollback) as any;
+          return false;
+        }
+
+        values.push(result.value);
+        rollbacks.push(() => result.rollback());
+        return true;
+      },
+      () => error || ok(values, rollback)
+    );
+  }
+
+  export function wrap<Fn extends (...args: any) => Promise<any>>(
+    fn: Fn
+  ): (
+    ...args: Parameters<Fn>
+  ) => Promise<Result<Error, PromiseReturnType<Fn>, never>>;
+  export function wrap<Fn extends (...args: any) => any>(
+    fn: Fn
+  ): (...args: Parameters<Fn>) => Result<Error, ReturnType<Fn>, never>;
+  export function wrap(fn: any) {
+    return function wrapped(...args: any) {
+      try {
+        const resultOrPromise = fn(...args);
+
+        if (resultOrPromise instanceof Promise) {
+          return resultOrPromise
+            .then((okValue) => Result.ok(okValue))
+            .catch((err) => error(err));
+        }
+
+        return ok(resultOrPromise);
+      } catch (err) {
+        return error(err);
+      }
+    };
+  }
+}
+
+abstract class Base<
+  ErrorType extends unknown,
+  OkType extends unknown,
+  RollbackFn extends RollbackFunction
+> implements IResult<ErrorType, OkType>
+{
+  constructor(protected readonly rollbackFn?: RollbackFn) {}
+
+  errorOrNull(): ErrorType | null {
+    if (this.isSuccess()) {
+      return null;
+    }
+
+    return (this as any).error as ErrorType;
+  }
+
+  getOrNull(): OkType | null {
+    if (this.isFailure()) {
+      return null;
+    }
+
+    return (this as any).value as OkType;
+  }
+
+  toString(): string {
+    throw new Error("Method not implemented.");
+  }
+  inspect(): string {
+    return this.toString();
+  }
+
+  fold<R>(
+    onSuccess: (value: OkType) => R,
+    onFailure: (error: ErrorType) => R
+  ): R;
+  fold<R>(
+    onSuccess: (value: OkType) => Promise<R>,
+    onFailure: (error: ErrorType) => Promise<R>
+  ): Promise<R>;
+  fold(onSuccess: any, onFailure: any) {
+    if (this.isFailure()) {
+      return onFailure(this.error);
+    }
+
+    return onSuccess((this as any).value as OkType);
+  }
+
+  getOrDefault(defaultValue: OkType): OkType {
+    if (this.isSuccess()) {
+      return this.value;
+    }
+
+    return defaultValue;
+  }
+
+  getOrElse(onFailure: (error: ErrorType) => OkType): OkType;
+  getOrElse(onFailure: (error: ErrorType) => Promise<OkType>): Promise<OkType>;
+  getOrElse(onFailure: any) {
+    if (this.isSuccess()) {
+      return isAsyncFn(onFailure) ? Promise.resolve(this.value) : this.value;
+    }
+
+    return onFailure((this as any).error as ErrorType);
+  }
+
+  getOrThrow(): OkType {
+    if (this.isFailure()) {
+      throw this.error;
+    }
+
+    return (this as any).value as OkType;
+  }
+
+  isSuccess(): this is Ok<ErrorType, OkType, RollbackFn> {
+    throw new Error("Method not implemented.");
+  }
+  isFailure(): this is Err<ErrorType, OkType, RollbackFn> {
+    throw new Error("Method not implemented.");
+  }
+
+  map<T>(
+    fn: (value: OkType) => Promise<T>
+  ): Promise<
+    JoinErrorTypes<
+      ErrorType,
+      T extends Result<any, any, any> ? T : Result<Error, T, any>
+    >
+  >;
+  map<T>(
+    fn: (value: OkType) => T
+  ): JoinErrorTypes<
+    ErrorType,
+    T extends Result<any, any, any> ? T : Result<Error, T, any>
+  >;
+  map(fn: any) {
+    if (this.isFailure()) {
+      return isAsyncFn(fn) ? Promise.resolve(this) : this;
+    }
+
+    const result = Result.safe(() => fn((this as any).value) as any);
+
+    return result as any;
+  }
+
+  rollback(): RollbackFn extends RollbackFunction
+    ? RollbackFn extends () => Promise<void>
+      ? Promise<Result<Error, void>>
+      : Result<Error, void>
+    : void {
+    if (this.rollbackFn) {
+      return this.rollbackFn() as any;
+    }
+
+    return null as any;
+  }
+}
+
+class Ok<
+  ErrorType extends unknown,
+  OkType extends unknown,
+  RollbackFn extends RollbackFunction
+> extends Base<ErrorType, OkType, RollbackFn> {
+  public readonly value: OkType;
+
+  constructor(val: OkType, rollbackFn?: RollbackFn) {
+    super(rollbackFn);
+    this.value = val;
+  }
+
+  isSuccess(): this is Ok<ErrorType, OkType, RollbackFn> {
+    return true;
+  }
+
+  isFailure(): this is Err<ErrorType, OkType, RollbackFn> {
+    return false;
+  }
+
+  toString(): string {
+    return `Result.Ok(${this.value})`;
+  }
+
+  forward(): Result<any, OkType, RollbackFn> {
+    return Result.ok(this.value);
+  }
+}
+
+class Err<
+  ErrorType extends unknown,
+  OkType extends unknown,
+  RollbackFn extends RollbackFunction
+> extends Base<ErrorType, OkType, RollbackFn> {
+  public readonly error: ErrorType;
+
+  constructor(err: ErrorType, rollbackFn?: RollbackFn) {
+    super(rollbackFn);
+    this.error = err;
+  }
+
+  isSuccess(): this is Ok<ErrorType, OkType, RollbackFn> {
+    return false;
+  }
+
+  isFailure(): this is Err<ErrorType, OkType, RollbackFn> {
+    return true;
+  }
+
+  toString(): string {
+    return `Result.Error(${this.error})`;
+  }
+
+  forward(): Result<ErrorType, any, RollbackFn> {
+    return Result.error(this.error);
+  }
+}

server/src/core/helper/typed_event.ts

@@ -0,0 +1,50 @@
+export interface Listener<T> {
+    (event: T): any;
+}
+
+export interface Disposable {
+    dispose():void;
+}
+
+
+export class TypedEvent<T> {
+    private listeners: Listener<T>[] = [];
+    public listenersOncer: Listener<T>[] = [];
+
+    on = (listener: Listener<T>): Disposable => {
+        this.listeners.push(listener);
+        return {
+            dispose: () => this.off(listener),
+        };
+    };
+
+    once = (listener: Listener<T>): void => {
+        this.listenersOncer.push(listener);
+    };
+
+    off = (listener: Listener<T>) => {
+        const callbackIndex = this.listeners.indexOf(
+            listener
+        );
+        if (callbackIndex > -1)
+            this.listeners.splice(callbackIndex, 1);
+    };
+
+    emit = (event: T) => {
+        /** Обновить слушателей */
+        this.listeners.forEach((listener) =>
+            listener(event)
+        );
+
+        /** Очистить очередь единожды */
+        if (this.listenersOncer.length > 0) {
+            const toCall = this.listenersOncer;
+            this.listenersOncer = [];
+            toCall.forEach((listener) => listener(event));
+        }
+    };
+
+    pipe = (te: TypedEvent<T>): Disposable => {
+        return this.on((e) => te.emit(e));
+    };
+}

server/src/core/helper/worker_computed.ts

@@ -0,0 +1,78 @@
+import { EXEC_EVENT, EXEC_TYPE, ExecError } from "../model/exec_error_model.js";
+import * as cp from "child_process";
+import { ExecutorResult } from "../model/executor_result.js";
+
+export enum WorkerType {
+  EXEC = "EXEC",
+  SPAWN = "SPAWN",
+}
+
+export interface WorkerDataExec {
+  command: string;
+  execPath: string;
+  type: WorkerType;
+  cliArgs:Array<string> | undefined
+}
+
+process.on("message", async (message) => {
+  const workerData = message as WorkerDataExec;
+  if (workerData.type == WorkerType.SPAWN) {
+    const subprocess = cp.spawn(workerData.command, workerData.cliArgs, {
+      cwd: workerData.execPath,
+    });
+
+    subprocess.stdout.on("data", (data: Buffer) => {
+      if (process.send) {
+        process.send({
+          type: EXEC_TYPE.SPAWN.toString(),
+          event: EXEC_EVENT.PROGRESS.toString(),
+          data: data.toString(),
+        });
+      }
+    });
+    subprocess.on('close', (_code) =>{
+      if (process.send) {
+        process.send({
+          type: EXEC_TYPE.SPAWN.toString(),
+          event: EXEC_EVENT.END.toString(),
+          data:null
+        });
+      }
+    })
+    process.on("uncaughtException", (error) => {
+      if (process.send) {
+        process.send({
+          command: workerData.command,
+          execPath: workerData.execPath,
+          error: error,
+        });
+      }
+    });
+  } else if (workerData.type == WorkerType.EXEC) {
+    try {
+       const result = await exec(workerData.command, {
+        cwd: workerData.execPath,
+      });
+      if (process.send) {
+        process.send(
+          new ExecutorResult(EXEC_TYPE.EXEC, EXEC_EVENT.END, result)
+        );
+      }
+    } catch (error) {
+       if (process.send) {
+        process.send(new ExecError(workerData.command, error ));
+      }
+    }
+  }
+});
+
+async function exec(
+  cmd: string,
+  opts: cp.ExecOptions & { trim?: boolean } = {}
+): Promise<string> {
+  return new Promise((c, e) => {
+    cp.exec(cmd, { env: process.env, ...opts }, (err, stdout) => {
+      return err ? e(err) : c(opts.trim ? stdout.trim() : stdout);
+    });
+  });
+}

server/src/core/model/exec_error_model.ts

@@ -0,0 +1,61 @@
+export class ExecError extends Error {
+  static isExecError(e: any) {
+    if ("type" in e && "script" in e && "unixTime" in e) {
+      return new ExecError(e.type, e.event, e.data);
+    }
+    return; 
+  }
+  script: string;
+  unixTime: number;
+  type = EXEC_TYPE.EXEC;
+
+  constructor(
+     script: string,
+    ...args: any
+  ) {
+    super(...args);
+     this.script = script;
+    this.unixTime = Date.now();
+  }
+}
+
+export class SpawnError extends Error {
+  environment: string;
+  script: string;
+  unixTime: number;
+  type = EXEC_TYPE.SPAWN;
+
+  constructor(
+    environment: string,
+    script: string,
+    ...args: any
+  ) {
+    super(...args);
+    this.environment = environment;
+    this.script = script;
+    this.unixTime = Date.now();
+  }
+  static isError(errorType: any): void | SpawnError {
+    if (
+      "command" in errorType &&
+      "error" in errorType &&
+      "execPath" in errorType
+    ) {
+      return new SpawnError(
+        errorType.command,
+        errorType.execPath,
+        errorType.error
+      );
+    }
+    return;
+  }
+}
+export enum EXEC_TYPE {
+  SPAWN = "SPAWN",
+  EXEC = "EXEC",
+}
+export enum EXEC_EVENT {
+  PROGRESS = "PROGRESS",
+  ERROR = "ERROR",
+  END = "END",
+}

server/src/core/model/executor_result.ts

@@ -0,0 +1,19 @@
+import { EXEC_EVENT, EXEC_TYPE } from "./exec_error_model.js";
+
+ 
+export class ExecutorResult {
+    type: EXEC_TYPE;
+    event: EXEC_EVENT;
+    data: any;
+    constructor(type: EXEC_TYPE, event: EXEC_EVENT, data: any) {
+      this.type = type;
+      this.event = event;
+      this.data = data;
+    }
+    static isExecutorResult(value: any): void | ExecutorResult {
+      if ("type" in value && "event" in value && "data" in value) {
+        return new ExecutorResult(value.type, value.event, value.data);
+      }
+      return;
+    }
+  }

server/src/core/model/meta_data_file_manager_model.ts

@@ -0,0 +1,29 @@
+export enum EventsFileChanger {
+  remove = "remove",
+  update = "update",
+  delete = "delete",
+  create = "create",
+  static = "static",
+}
+
+export class MetaDataFileManagerModel {
+  path: string;
+  md5Hash: string | null;
+  event: EventsFileChanger;
+  unixTime: number;
+
+  constructor(path: string, md5Hash: string | null, event: EventsFileChanger) {
+    this.path = path;
+    this.md5Hash = md5Hash;
+    this.event = event;
+    this.unixTime = Date.now();
+  }
+  public get timeString(): string {
+    const date = new Date(this.unixTime * 1000);
+    const hours = date.getHours();
+    const minutes = "0" + date.getMinutes();
+    const seconds = "0" + date.getSeconds();
+
+    return hours + ":" + minutes.substr(-2) + ":" + seconds.substr(-2);
+  }
+}

server/src/core/model/process_model.ts

@@ -0,0 +1,45 @@
+export class CalculationProcess {
+  process: ProcessMetaData[];
+  constructor(process: ProcessMetaData[]) {
+    this.process = process;
+  }
+}
+
+export interface ProcessMetaData {
+  process: Process;
+  trigger: Trigger;
+  env: Env | null;
+}
+
+export enum ProcessType {
+  EXEC = "EXEC",
+  SPAWN = "SPAWN",
+}
+export interface Env {
+  ssh_key: string;
+  isUserInput: boolean;
+  isExtends: string;
+}
+
+export interface Process {
+  type: ProcessType; 
+  command: string;
+  isGenerating: boolean;
+  isLocaleCode: boolean;
+  issueType: IssueType;
+  timeout: number;
+}
+
+export enum IssueType {
+  WARNING = "WARNING",
+  ERROR = "ERROR",
+}
+
+export enum TriggerType {
+  PROCESS = "PROCESS",
+  FILE = "FILE",
+}
+export interface Trigger {
+  type: TriggerType;
+  value: string;
+}

server/src/core/services/executor_program_service.ts

@@ -0,0 +1,82 @@
+import cluster, { Worker } from "node:cluster";
+import { TypedEvent } from "../helper/typed_event.js";
+import { Result } from "../helper/result.js";
+import { WorkerDataExec, WorkerType } from "../helper/worker_computed.js";
+import { delay } from "../helper/delay.js";
+import { ExecutorResult } from "../model/executor_result.js";
+import { EXEC_TYPE, ExecError, SpawnError } from "../model/exec_error_model.js";
+
+abstract class IExecutorProgramService {
+  abstract execPath: string;
+}
+
+export class ExecutorProgramService
+  extends TypedEvent<Result<ExecError | SpawnError, ExecutorResult>>
+  implements IExecutorProgramService
+{
+  static event = "ExecutorProgramService";
+  execPath: string;
+  worker: Worker | any;
+  maxTime: null | number = null;
+
+  constructor(execPath: string, maxTime: number | null = null) {
+    super();
+    this.execPath = execPath;
+    this.maxTime = maxTime;
+  }
+  private async workerExecuted(command: string, workerType: WorkerType,args:Array<string> | undefined = undefined) {
+    cluster.setupPrimary({
+      exec: "./src/core/helper/worker_computed.js",
+    });
+
+    const worker = cluster.fork();
+
+    await delay(300);
+
+    this.worker = worker;
+
+    const workerDataExec: WorkerDataExec = {
+      command: command,
+      execPath: this.execPath,
+      type: workerType,
+      cliArgs:args
+    };
+    worker.send(workerDataExec);
+    worker.on("message", (e) => {
+      const spawnError = SpawnError.isError(e);
+      if (spawnError instanceof SpawnError) {
+        this.emit(Result.error(spawnError));
+      }
+      const executorResult = ExecutorResult.isExecutorResult(e);
+      if (executorResult instanceof ExecutorResult) {
+        this.emit(Result.ok(executorResult));
+      }
+
+      const execError = ExecError.isExecError(e);
+      if (execError instanceof ExecError) {
+        this.emit(Result.error(execError));
+      }
+    });
+    if (this.maxTime != null) {
+      setTimeout(() => {
+        this.worker.kill();
+        this.emit(
+          Result.error(
+            WorkerType.EXEC
+              ? new ExecError(command, "timeout err")
+              : new SpawnError(command, "timeout err")
+          )
+        );
+      }, this.maxTime!);
+    }
+  }
+  public async call(type: EXEC_TYPE, command: string, args:Array<string> | undefined = undefined): Promise<void> {
+    if (type == EXEC_TYPE.EXEC) {
+      this.workerExecuted(command, WorkerType.EXEC);
+
+      return;
+    }
+    this.workerExecuted(command, WorkerType.SPAWN,args);
+    return;
+  }
+}

server/src/core/services/files_change_notifier_service.ts

@@ -0,0 +1,122 @@
+import * as fs from "fs";
+import { resolve } from "node:path";
+import { promisify } from "node:util";
+import { createHash } from "node:crypto";
+import "reflect-metadata";
+import { BinaryLike } from "crypto";
+import { EventsFileChanger, MetaDataFileManagerModel } from "../model/meta_data_file_manager_model.js";
+import { Result } from "../helper/result.js";
+import { TypedEvent } from "../helper/typed_event.js";
+
+const readFileAsync = promisify(fs.readFile);
+const readdir = promisify(fs.readdir);
+const stat = promisify(fs.stat);
+
+function md5(content: Buffer | BinaryLike) {
+  return createHash("md5").update(content).digest("hex");
+}
+ 
+interface IHashesCache {
+  [key: string]: MetaDataFileManagerModel;
+}
+export abstract class IFilesChangeNotifierService {
+  abstract directory: string;
+}
+export class FilesChangeNotifierService
+  extends TypedEvent<Result<Error, IHashesCache>>
+  implements IFilesChangeNotifierService
+{
+  watcher!: fs.FSWatcher;
+  directory: string;
+  constructor(directory: string) {
+    super();
+    this.directory = directory;
+    this.init();
+  }
+  hashes: IHashesCache = {};
+  async init() {
+    const files = await this.getFiles(this.directory);
+    for (const file of files) {
+      await this.setHash(file);
+    }
+  }
+  async setHash(file: string) {
+    const data = await readFileAsync(file);
+    const md5Current = md5(data);
+
+    this.hashes[file] = new MetaDataFileManagerModel(
+      file,
+      md5Current,
+      EventsFileChanger.static
+    );
+    this.emit(Result.ok(this.hashes));
+  }
+  async getFiles(dir: string): Promise<string | any[]> {
+    const subdirs = await readdir(dir);
+    const files = await Promise.all(
+      subdirs.map(async (subdir) => {
+        const res = resolve(dir, subdir);
+        return (await stat(res)).isDirectory() ? this.getFiles(res) : res;
+      })
+    );
+    return files.reduce((a: string | any[], f: any) => a.concat(f), []);
+  }
+
+  public call = (): Result<Error, boolean> => {
+    try {
+      let md5Previous: string | null = null;
+      let fsWait: NodeJS.Timeout | boolean = false;
+      const watcher = fs.watch(
+        this.directory,
+        { recursive: true },
+        async (_e, filename) => {
+          const filePath = this.directory + filename;
+          if (filename) {
+            if (fsWait) return;
+            fsWait = setTimeout(() => {
+              fsWait = false;
+            }, 100);
+            try {
+              const file = await readFileAsync(filePath);
+              const md5Current = md5(file);
+
+              if (md5Current === md5Previous) {
+                return;
+              }
+              const status = this.hashes[filePath] === undefined
+                  ? EventsFileChanger.create
+                  : EventsFileChanger.update;
+             
+              const model = new MetaDataFileManagerModel(
+                filePath,
+                md5Current,
+                status
+              );
+              this.hashes[filePath] = model;
+              md5Previous = md5Current;
+              this.emit(Result.ok(this.hashes));
+            } catch (error) {
+              this.emit(Result.ok(this.hashes));
+              this.hashes[filePath] = new MetaDataFileManagerModel(
+                filePath,
+                null,
+                EventsFileChanger.delete
+              );
+            }
+          }
+        }
+      );
+      this.watcher = watcher;
+      return Result.ok(true);
+    } catch (error) {
+      return Result.error(error as Error);
+    }
+  };
+  cancel() {
+    if (this.watcher != undefined) {
+      this.watcher.close();
+      this.listenersOncer = []
+    }
+
+  }
+}

server/src/index.ts

@@ -0,0 +1 @@
+export {}