crud and http controller

server/src/core/controllers/app.ts

@@ -0,0 +1,79 @@
+import express from "express";
+import { Routes } from "../interfaces/router";
+import cors from "cors";
+import locator from "../di/register_di";
+import { DevEnv, UnitTestEnv } from "../di/env";
+import mongoose from "mongoose";
+import http from "http";
+import { Server } from "socket.io";
+
+export class App {
+  public app: express.Application;
+  public port: number;
+  public env: string;
+  public computedFolder: string;
+  // public io:
+  constructor(routes: Routes[], computedFolder: string) {
+    this.app = express();
+    this.port = Number(process.env.PORT) || 3000;
+    this.env = "dev";
+    this.initializeMiddlewares();
+    this.initializeRoutes(routes);
+    this.loadAppDependencies();
+    this.computedFolder = computedFolder;
+  }
+
+  public listen() {
+    const httpServer = new http.Server(this.app);
+    // const io = new Server(httpServer);
+
+    httpServer.listen(this.port, () => {
+      console.info(`=================================`);
+      console.info(`======= ENV: ${this.env} =======`);
+      console.info(`🚀 HTTP http://localhost:${this.port}`);
+      console.info(`🚀 WS ws://localhost:${this.port}`);
+      console.info(`=================================`);
+    });
+    // io.on("connection", (socket) => {
+    //   socket.on("disconnect", function (msg) {
+    //     console.log("Disconnected");
+    //   });
+    // });
+
+    // setInterval(function () {
+    //   io.emit("goodbye");
+    //   console.log(200);
+    // }, 1000);
+ 
+  }
+
+  public getServer() {
+    return this.app;
+  }
+
+  private initializeMiddlewares() {
+    this.app.use(cors());
+    this.app.use(express.json());
+    this.app.use(express.urlencoded({ extended: true }));
+  }
+
+  private initializeRoutes(routes: Routes[]) {
+    routes.forEach((route) => {
+      this.app.use("/", route.router);
+    });
+  }
+  loadAppDependencies() {
+    locator(
+      this.env == "development"
+        ? new DevEnv(this.computedFolder)
+        : new UnitTestEnv(this.computedFolder)
+    );
+
+    mongoose
+      .connect("mongodb://127.0.0.1:27017/test")
+      .then(() => console.log("Connected!"))
+      .catch((e) => {
+        console.log("ERROR:", e);
+      });
+  }
+}

server/src/core/controllers/crud_controller.ts

@@ -0,0 +1,34 @@
+import { IRouteModel } from "../interfaces/router";
+import { CreateDataBaseModelUseCase } from "../usecases/create_database_model_usecase";
+import { DeleteDataBaseModelUseCase } from "../usecases/delete_database_model_usecase";
+import { PaginationDataBaseModelUseCase } from "../usecases/pagination_database_model_usecase";
+import { UpdateDataBaseModelUseCase } from "../usecases/update_database_model_usecase";
+
+import { CoreHttpController } from "./http_controller";
+import mongoose from "mongoose";
+
+export class CrudController<V, D> extends CoreHttpController<V> {
+  dataBaseModel: mongoose.Model<D>;
+
+  constructor(routerModel: IRouteModel) {
+    super(routerModel);
+    this.url = "/" + routerModel.url;
+    this.validationModel = routerModel.validationModel;
+    this.dataBaseModel = routerModel.databaseModel;
+    this.init();
+  }
+  init() {
+    this.routes["POST"] = new CreateDataBaseModelUseCase<D>(
+      this.dataBaseModel
+    ).call;
+    this.routes["GET"] = new PaginationDataBaseModelUseCase<D>(
+      this.dataBaseModel
+    ).call;
+    this.routes["DELETE"] = new DeleteDataBaseModelUseCase<D>(
+      this.dataBaseModel
+    ).call;
+    this.routes["PUT"] = new UpdateDataBaseModelUseCase<V, D>(
+      this.dataBaseModel
+    ).call;
+  }
+}

server/src/core/controllers/http_controller.ts

@@ -0,0 +1,115 @@
+import { validationModelMiddleware } from "../middlewares/validation_model";
+import { Result } from "../helper/result";
+import { Router, Request, Response } from "express";
+import { IRouteModel, Routes } from "../interfaces/router";
+ 
+ 
+export type CallBackFunction<T> = (a: T) => Promise<Result<any, any>>;
+
+abstract class ICoreHttpController {
+  abstract url: string;
+  public router = Router();
+  abstract call(): Routes;
+}
+
+export class CoreHttpController<V> implements ICoreHttpController {
+  url: string;
+  validationModel: any;
+
+  routes = {
+    POST: null,
+    GET: null,
+    DELETE: null,
+    PUT: null,
+  };
+
+  public router = Router();
+
+  constructor(routerModel: IRouteModel) {
+    this.url = "/" + routerModel.url;
+    this.validationModel = routerModel.validationModel;
+  }
+
+  call(): Routes {
+    if (this.routes["POST"] != null) {
+      this.router.post(
+        this.url,
+        validationModelMiddleware(this.validationModel),
+        (req, res) =>
+          this.requestResponseController<V>(req, res, this.routes["POST"])
+      );
+    }
+    if (this.routes["DELETE"] != null) {
+      this.router.delete(
+        this.url,
+        (req, res) =>
+          this.requestResponseController<V>(req, res, this.routes["DELETE"])
+      );
+    }
+    if (this.routes["PUT"] != null) {
+      this.router.put(
+        this.url,
+        validationModelMiddleware(this.validationModel),
+        (req, res) =>
+          this.requestResponseController<V>(req, res, this.routes["PUT"])
+      );
+    }
+    if (this.routes["GET"] != null) {
+      this.router.get(this.url, (req, res) =>
+        this.requestResponseController<V>(req, res, this.routes["GET"])
+      );
+    }
+
+    return {
+      router: this.router,
+    };
+  }
+  public put(usecase: CallBackFunction<V>) {
+    this.routes["PUT"] = usecase;
+  }
+  public delete(usecase: CallBackFunction<V>) {
+    this.routes["DELETE"] = usecase;
+  }
+  private async requestResponseController<T>(
+    req: Request,
+    res: Response,
+    usecase: CallBackFunction<T>
+  ) {
+    let payload = null
+
+    if (req["model"] != undefined) {
+      payload = req.body as T
+
+    }
+
+    if (req.query.page !== undefined) {
+      payload = String(req.query.page)
+
+    }
+
+    if (req.query.id !== undefined) {
+      payload = String(req.query.id)
+    }
+
+    
+
+    (await usecase(payload)).fold(
+      (ok) => {
+        res.json(ok);
+        return;
+      },
+      (err) => {
+        res.status(400).json(err);
+        return;
+      }
+    );
+  }
+  public post(usecase: CallBackFunction<V>) {
+    this.routes["POST"] = usecase;
+  }
+
+  public get(usecase: CallBackFunction<V>) {
+    this.routes["GET"] = usecase;
+  }
+}
+ 

server/src/core/controllers/socket_controller.ts

@@ -0,0 +1,15 @@
+import path from "path";
+import { TypedEvent } from "../helper/typed_event";
+import { StackService } from "../services/stack_service";
+// TODO(IDONTSUDO): up to do
+
+class SocketController<T>{ 
+    emitter:TypedEvent<T>;
+    constructor(emitter:TypedEvent<T>, ){
+        this.emitter = emitter
+    }
+    call = () =>{
+
+    }
+}
+  

server/src/core/di/env.ts

@@ -1,6 +1,4 @@
-import { reflection } from "first-di";
-
-@reflection
+ 
 export class IEnv{
     rootFolder!: string; 
     constructor(){
@@ -14,8 +12,7 @@ export class IEnv{
     }
 }
 
-@reflection
-export class DevEnv implements IEnv {
+ export class DevEnv implements IEnv {
     rootFolder:string;
     constructor(rootFolder:string){
         this.rootFolder = rootFolder
@@ -29,7 +26,6 @@ export class DevEnv implements IEnv {
     }
 }
 
-@reflection
 export class UnitTestEnv implements IEnv{
     rootFolder:string;
     constructor(rootFolder:string){

server/src/core/di/register_di.ts

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

server/src/core/extensions/extensions.ts

@@ -1,4 +1,4 @@
-import { ArrayEquals } from "./array.js";
+import { ArrayEquals } from "./array";
 
 export const extensions = () =>{
     ArrayEquals()

server/src/core/helper/cancelable_promise.ts

@@ -1,248 +1 @@
-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/worker_computed.ts

@@ -1,6 +1,6 @@
-import { EXEC_EVENT, EXEC_TYPE, ExecError } from "../model/exec_error_model.js";
+import { EXEC_EVENT, EXEC_TYPE, ExecError } from "../model/exec_error_model";
 import * as cp from "child_process";
-import { ExecutorResult } from "../model/executor_result.js";
+import { ExecutorResult } from "../model/executor_result";
 
 export enum WorkerType {
   EXEC = "EXEC",

server/src/core/interfaces/payload.ts

@@ -0,0 +1,14 @@
+ 
+// export class Payload<T>{
+//     model: T | undefined
+//     query:string | undefined
+//     setModel(model:T){
+//       this.model = model
+//     }
+//     setQuery(query:string){
+//       this.query = query
+//     }
+//     isEmpty(){
+//       return this.model != undefined || this.query != undefined
+//     }
+//   }

server/src/core/interfaces/response.ts

@@ -0,0 +1,3 @@
+export interface ICreateObjectDataBase {
+  id: string;
+}

server/src/core/interfaces/router.ts

@@ -0,0 +1,14 @@
+import { Router } from "express";
+
+export interface Routes {
+  router: Router;
+}
+
+export interface IRouteModel {
+  validationModel: any;
+  url: string;
+  databaseModel: any;
+}
+
+
+ 

server/src/core/middlewares/validation_auth.ts

@@ -0,0 +1,12 @@
+// import { RequestHandler } from "express";
+
+// export const validationMiddleware = (
+//     type: any,
+//     value = 'body',
+//     skipMissingProperties = false,
+//     whitelist = true,
+//     forbidNonWhitelisted = true,
+//   ): RequestHandler => {
+
+
+// }  

server/src/core/middlewares/validation_model.ts

@@ -0,0 +1,30 @@
+import { plainToInstance } from 'class-transformer';
+import { validate, ValidationError } from 'class-validator';
+import { RequestHandler } from 'express';
+ 
+export const validationModelMiddleware = (
+  type: any,
+  value = 'body',
+  skipMissingProperties = false,
+  whitelist = true,
+  forbidNonWhitelisted = true,
+): RequestHandler => {
+  return (req, res, next) => {
+    if(type === null && type == undefined){
+        next()
+        return
+    }
+    const model = plainToInstance(type, req[value]);
+    validate(model, { skipMissingProperties, whitelist, forbidNonWhitelisted }).then((errors: ValidationError[]) => {
+      console.log(errors)
+      if (errors.length > 0) {
+        const message = errors.map((error: ValidationError) => Object.values(error.constraints)).join(', ');
+        return res.status(400).json(message)
+      } else {
+        req['model'] =  model
+        next();
+      }
+    });
+  };
+};
+

server/src/core/model/executor_result.ts

@@ -1,4 +1,4 @@
-import { EXEC_EVENT, EXEC_TYPE } from "./exec_error_model.js";
+import { EXEC_EVENT, EXEC_TYPE } from "./exec_error_model";
 
  
 export class ExecutorResult {

server/src/core/model/process_model.ts

@@ -1,4 +1,5 @@
-import { EXEC_TYPE } from "./exec_error_model.js";
+import { Trigger } from "../../features/triggers/trigger_model";
+import { EXEC_TYPE } from "./exec_error_model";
 
  
 export interface ProcessMetaData {
@@ -34,11 +35,4 @@ export enum IssueType {
   ERROR = "ERROR",
 }
 
-export enum TriggerType {
-  PROCESS = "PROCESS",
-  FILE = "FILE",
-}
-export interface Trigger {
-  type: TriggerType;
-  value: string[];
-}
+ 

server/src/core/services/executor_program_service.ts

@@ -1,10 +1,10 @@
 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";
+import { TypedEvent } from "../helper/typed_event";
+import { Result } from "../helper/result";
+import { WorkerDataExec, WorkerType } from "../helper/worker_computed";
+import { delay } from "../helper/delay";
+import { ExecutorResult } from "../model/executor_result";
+import { EXEC_TYPE, ExecError, SpawnError } from "../model/exec_error_model";
 
 abstract class IExecutorProgramService {
   abstract execPath: string;
@@ -31,7 +31,7 @@ export class ExecutorProgramService
     args: Array<string> | undefined = undefined
   ) {
     cluster.setupPrimary({
-      exec: "./src/core/helper/worker_computed.js",
+      exec: "./src/core/helper/worker_computed",
     });
 
     const worker = cluster.fork();

server/src/core/services/files_change_notifier_service.ts

@@ -7,16 +7,16 @@ 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";
+} from "../model/meta_data_file_manager_model";
+import { Result } from "../helper/result";
+import { TypedEvent } from "../helper/typed_event";
 
 const readFileAsync = promisify(fs.readFile);
 const readdir = promisify(fs.readdir);
 const stat = promisify(fs.stat);
 const lsStat = promisify(fs.lstat);
 
-function joinBuffers(buffers, delimiter = " ") {
+function joinBuffers(buffers:Array<Buffer>, delimiter = " ") {
   const d = Buffer.from(delimiter);
   return buffers.reduce((prev, b) => Buffer.concat([prev, d, b]));
 }

server/src/core/services/stack_service.ts

@@ -1,19 +1,20 @@
 import {
   FilesChangeNotifierService,
   IHashesCache,
-} from "./files_change_notifier_service.js";
-import { ProcessMetaData, Trigger } from "../model/process_model.js";
-import { ExecutorProgramService } from "./executor_program_service.js";
+} from "./files_change_notifier_service";
+import { ProcessMetaData } from "../model/process_model";
+import { ExecutorProgramService } from "./executor_program_service";
 import {
   EXEC_EVENT,
   ExecError,
   SpawnError,
-} from "../model/exec_error_model.js";
-import { TypedEvent } from "../helper/typed_event.js";
-import { Result } from "../helper/result.js";
-import { ExecutorResult } from "../model/executor_result.js";
-import { delay } from "../helper/delay.js";
-import { TriggerErrorReport, TriggerService } from "./trigger_service.js";
+} from "../model/exec_error_model";
+import { TypedEvent } from "../helper/typed_event";
+import { Result } from "../helper/result";
+import { ExecutorResult } from "../model/executor_result";
+import { delay } from "../helper/delay";
+import { TriggerErrorReport, TriggerService } from "./trigger_service";
+import { Trigger } from "../../features/triggers/trigger_model";
 
 export interface Iteration {
   hashes: IHashesCache | null;

server/src/core/services/trigger_service.ts

@@ -1,9 +1,12 @@
-import { Trigger, TriggerType } from "../model/process_model.js";
 import * as vm from "node:vm";
-import { IHashesCache } from "./files_change_notifier_service.js";
-import { EventsFileChanger } from "../model/meta_data_file_manager_model.js";
-import { Result } from "../helper/result.js";
-import { TypedEvent } from "../helper/typed_event.js";
+import { IHashesCache } from "./files_change_notifier_service";
+import { EventsFileChanger } from "../model/meta_data_file_manager_model";
+import { Result } from "../helper/result";
+import { TypedEvent } from "../helper/typed_event";
+import {
+  Trigger,
+  TriggerType,
+} from "../../features/triggers/trigger_model";
 
 export class TriggerCallResult {
   results: Array<TriggerSuccessResult | TriggerErrorReport>;
@@ -47,7 +50,7 @@ export class TriggerErrorReport extends Error {
   }
 }
 export class TriggerService extends TypedEvent<TriggerCallResult> {
-  context = {};
+  context:any = {};
 
   constructor(trigger: Trigger, hashes: IHashesCache, path: string) {
     super();
@@ -61,8 +64,11 @@ export class TriggerService extends TypedEvent<TriggerCallResult> {
   path: string;
   hashes: IHashesCache;
   trigger: Trigger;
+
   private init(): void {
-    this.context["hashes"] = this.hashes;
+    if (this.context["hashes"] != undefined) {
+      this.context["hashes"] = this.hashes;
+    }
   }
   private getAllHashesDeleteWithouts(): string[] {
     return Object.entries(this.hashes).map(([k, v]) => {

server/src/core/usecases/create_database_model_usecase.ts

@@ -0,0 +1,22 @@
+import { Result } from "../helper/result";
+import { ICreateObjectDataBase } from "../interfaces/response";
+
+export class CreateDataBaseModelUseCase<V> {
+  databaseModel: any;
+
+  constructor(model) {
+    this.databaseModel = model;
+  }
+
+  call = async (
+    validationModel: V
+  ): Promise<Result<Error, ICreateObjectDataBase>> => {
+    try {
+      const result = new this.databaseModel(validationModel);
+
+      return Result.ok({ id: String((await result.save())._id) });
+    } catch (error) {
+      return Result.error(error);
+    }
+  };
+}

server/src/core/usecases/delete_database_model_usecase.ts

@@ -0,0 +1,18 @@
+ import { Result } from "../helper/result";
+
+export class DeleteDataBaseModelUseCase<D> {
+  databaseModel: D | any; 
+  constructor(model) {
+    this.databaseModel = model;
+  }
+  call = async (id: string): Promise<Result<Error, boolean>> => {
+    try {
+      const model = new this.databaseModel({ _id: id });
+      await model.deleteOne();
+
+      return Result.ok(true);
+    } catch (error) {
+      return Result.error(error);
+    }
+  };
+}

server/src/core/usecases/pagination_database_model_usecase.ts

@@ -0,0 +1,28 @@
+import { Result } from "../helper/result";
+
+export class PaginationDataBaseModelUseCase<D> {
+  databaseModel: D;
+  perPage: number;
+
+  constructor(model: any, perPage = 10) {
+    this.databaseModel = model;
+    this.perPage = perPage;
+  }
+
+  call = async (
+    pageNumber: number
+  ): Promise<Result<Error, [D]>> => {
+    try {
+      const page = Math.max(0, pageNumber);
+      const model = this.databaseModel as any;
+      return Result.ok(
+        await model
+          .find()
+          .limit(this.perPage)
+          .skip(this.perPage * page)
+      );
+    } catch (error) {
+      return Result.error(error);
+    }
+  };
+}

server/src/core/usecases/read_database_model_usecase.ts

@@ -0,0 +1,20 @@
+
+import { Result } from "../helper/result";
+
+export class ReadByIdDataBaseModelUseCase<D> {
+  databaseModel: D;
+
+  constructor(model) {
+    this.databaseModel = model;
+  }
+  call = async (id: string): Promise<Result<Error, D>> => {
+    try {
+      const r = this.databaseModel as any;
+
+      const model = await r.findById(id);
+      return Result.ok(model);
+    } catch (error) {
+      return Result.error(error);
+    }
+  };
+}

server/src/core/usecases/update_database_model_usecase.ts

@@ -0,0 +1,27 @@
+import { Result } from "../helper/result";
+
+interface uuid {
+  _id?: string;
+}
+
+export class UpdateDataBaseModelUseCase<D, T extends uuid> {
+  databaseModel: D;
+  constructor(databaseModel) {
+    this.databaseModel = databaseModel;
+  }
+
+  call = async (updateModel: T): Promise<Result<Error, T>> => {
+    try {
+      if (updateModel["_id"] === undefined) {
+        return Result.error(new Error("need _id at model body"));
+      }
+      const databaseModel = this.databaseModel as any;
+      const model = await databaseModel.findById(updateModel._id);
+      Object.assign(model, updateModel);
+      await model.save();
+      return Result.ok(model as T);
+    } catch (error) {
+      return Result.error(error);
+    }
+  };
+}

server/src/features/compositions/composition_model.ts

@@ -0,0 +1,19 @@
+import { IsArray, IsString, IsOptional } from "class-validator";
+import { Schema, model } from "mongoose";
+
+export interface ICompositionModel {
+
+}
+
+export const CompositionSchema = new Schema({
+
+});
+
+const schema = "Composition";
+
+export const CompositionDBModel = model<ICompositionModel>(schema, CompositionSchema);
+
+export class CompositionModel implements ICompositionModel {
+
+}
+

server/src/features/compositions/compositions_presentation.ts

@@ -0,0 +1,16 @@
+import { CrudController } from "../../core/controllers/crud_controller";
+import { CompositionDBModel, CompositionModel } from "./composition_model";
+
+export class CompositionPresentation extends CrudController<
+  CompositionModel,
+  typeof CompositionDBModel
+> {
+  constructor() {
+    super({
+      url: "compositions",
+      validationModel: CompositionModel,
+      databaseModel: CompositionDBModel,
+    });
+  }
+  
+}

server/src/features/functions/functions_model.ts

@@ -0,0 +1,19 @@
+import { IsArray, IsString, IsOptional } from "class-validator";
+import { Schema, model } from "mongoose";
+
+export interface IFunctionsModel {
+
+}
+
+export const FunctionsSchema = new Schema({
+
+});
+
+const schema = "Functions";
+
+export const FunctionsDBModel = model<IFunctionsModel>(schema, FunctionsSchema);
+
+export class FunctionsModel implements IFunctionsModel {
+
+}
+

server/src/features/functions/functions_presentation.ts

@@ -0,0 +1,15 @@
+import { CrudController } from "../../core/controllers/crud_controller";
+import { FunctionsDBModel, FunctionsModel } from "./functions_model";
+
+export class FunctionsPresentation extends CrudController<
+  FunctionsModel,
+  typeof FunctionsDBModel
+> {
+  constructor() {
+    super({
+      url: "functions",
+      validationModel: FunctionsModel,
+      databaseModel: FunctionsDBModel,
+    });
+  }
+}

server/src/features/projects/projects_model.ts

@@ -0,0 +1,14 @@
+import { IsArray, IsString, IsOptional } from "class-validator";
+import { Schema, model } from "mongoose";
+
+export interface IProjectModel {}
+ 
+export const ProjectSchema = new Schema({
+
+});
+
+const schema = "Projects";
+
+export const ProjectDBModel = model<IProjectModel>(schema, ProjectSchema);
+
+export class ProjectModel implements IProjectModel {}

server/src/features/projects/projects_presentation.ts

@@ -0,0 +1,16 @@
+// import { TriggerDBModel, TriggerModel } from "./trigger_model";
+import { CrudController } from "../../core/controllers/crud_controller";
+import { ProjectDBModel, ProjectModel } from "./projects_model";
+
+export class ProjectsPresentation extends CrudController<
+  ProjectModel,
+  typeof ProjectDBModel
+> {
+  constructor() {
+    super({
+      url: "project",
+      validationModel: ProjectModel,
+      databaseModel: ProjectDBModel,
+    });
+  }
+}

server/src/features/triggers/trigger_model.ts

@@ -0,0 +1,43 @@
+import { IsArray, IsString, IsOptional } from "class-validator";
+import { Schema, model } from "mongoose";
+
+export interface ITriggerModel {
+  _id?: string;
+  type: string;
+  value: string[];
+}
+
+export const TriggerSchema = new Schema({
+  type: {
+    type: String,
+    require: true,
+  },
+  value: {
+    type: Array,
+    require: true,
+  },
+});
+
+const schema = "Trigger";
+
+export const TriggerDBModel = model<ITriggerModel>(schema, TriggerSchema);
+
+export class TriggerModel implements ITriggerModel {
+  @IsOptional()
+  public _id: string;
+  @IsString()
+  public type: string;
+
+  @IsArray()
+  public value: string[];
+}
+
+export interface Trigger {
+  type: TriggerType;
+  value: string[];
+}
+
+export enum TriggerType {
+  PROCESS = "PROCESS",
+  FILE = "FILE",
+}

server/src/features/triggers/triggers_presentation.ts

@@ -0,0 +1,15 @@
+import { TriggerDBModel, TriggerModel } from "./trigger_model";
+import { CrudController } from "../../core/controllers/crud_controller";
+
+export class TriggerPresentation extends CrudController<
+  TriggerModel,
+  typeof TriggerDBModel
+> {
+  constructor() {
+    super({
+      url: "trigger",
+      validationModel: TriggerModel,
+      databaseModel: TriggerDBModel,
+    });
+  }
+}

server/src/index.ts

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

server/src/main.ts

@@ -0,0 +1,21 @@
+import "reflect-metadata";
+import { App } from "./core/controllers/app";
+import { TriggerPresentation } from "./features/triggers/triggers_presentation";
+import { ProjectsPresentation } from "./features/projects/projects_presentation";
+import { FunctionsPresentation } from "./features/functions/functions_presentation";
+import { CompositionPresentation } from "./features/compositions/compositions_presentation";
+import { Routes } from "./core/interfaces/router";
+
+import { Container, Service } from 'typedi';
+ 
+
+const httpRoutes: Routes[] = [
+  new TriggerPresentation(),
+  new ProjectsPresentation(),
+  new FunctionsPresentation(),
+  new CompositionPresentation(),
+].map((el) => el.call());
+
+const computedFolder = "";
+
+new App(httpRoutes, computedFolder).listen();