wip: implementing executor

libs/prisma/src/executors/prisma.executor.ts

@@ -15,4 +15,10 @@ export class PrismaExecutor {
   getResult(): any {
     return this.process.result();
   }
+
+  static async default(process: ISkeletonProcess): Promise<any> {
+    const executor = new PrismaExecutor(process);
+    await executor.execute();
+    return executor.getResult();
+  }
 }

libs/prisma/src/prisma-crud.controller.ts

@@ -3,8 +3,6 @@ import { PrismaExecutor } from './executors/prisma.executor';
 
 export class PrismaCRUDController extends SkeletonCRUDController {
   async create(): Promise<any> {
-    const executor = new PrismaExecutor(this.createProcess);
+    return await PrismaExecutor.default(this.createProcess);
-    await executor.execute();
-    return executor.getResult();
   }
 }

libs/prisma/src/processes/create.process.ts

@@ -1,18 +1,17 @@
 import { CreateProcess } from '@autocrud/skeleton/processes/create.process';
-import { Prisma, PrismaClient } from '@prisma/client';
 
-export abstract class PrismaCreateProcess implements CreateProcess {
+export class PrismaCreateProcess implements CreateProcess {
-  constructor(private readonly prisma: PrismaClient) {}
+  initialization();
+  before();
+  begin();
 
-  abstract initialization(): T;
-  abstract before(): T;
-  abstract begin(): T;
   process(): T {
     this.prisma['asd'].create({
       data,
     });
   }
-  abstract end(): T;
+
-  abstract after(): T;
+  end();
-  abstract result(): R;
+  after();
+  result();
 }

libs/skeleton/src/executors/default.executor.ts

@@ -0,0 +1,24 @@
+import { ISkeletonProcess } from '../interfaces/skeleton-process.interface';
+
+export class DefaultExecutor {
+  constructor(private process: ISkeletonProcess) {}
+
+  async execute(): Promise<void> {
+    this.process.initialization();
+    this.process.before();
+    this.process.begin();
+    this.process.process();
+    this.process.end();
+    this.process.after();
+  }
+
+  getResult(): any {
+    return this.process.result();
+  }
+
+  static async bootstrap(process: ISkeletonProcess): Promise<any> {
+    const executor = new DefaultExecutor(process);
+    await executor.execute();
+    return executor.getResult();
+  }
+}

libs/skeleton/src/processes/batch/delete.process.ts

@@ -1,11 +1,11 @@
 import { ISkeletonProcess } from '@autocrud/skeleton/interfaces/skeleton-process.interface';
 
 export abstract class BatchDeleteProcess implements ISkeletonProcess {
-  abstract initialization();
+  async initialization(): Promise<any> {}
-  abstract before();
+  async before(): Promise<any> {}
-  abstract begin();
+  async begin(): Promise<any> {}
-  abstract process();
+  async process(): Promise<any> {}
-  abstract end();
+  async end(): Promise<any> {}
-  abstract after();
+  async after(): Promise<any> {}
-  abstract result();
+  async result(): Promise<any> {}
 }

libs/skeleton/src/processes/batch/update.process.ts

@@ -1,11 +1,11 @@
 import { ISkeletonProcess } from '@autocrud/skeleton/interfaces/skeleton-process.interface';
 
 export abstract class BatchUpdateProcess implements ISkeletonProcess {
-  abstract initialization();
+  async initialization(): Promise<any> {}
-  abstract before();
+  async before(): Promise<any> {}
-  abstract begin();
+  async begin(): Promise<any> {}
-  abstract process();
+  async process(): Promise<any> {}
-  abstract end();
+  async end(): Promise<any> {}
-  abstract after();
+  async after(): Promise<any> {}
-  abstract result();
+  async result(): Promise<any> {}
 }

libs/skeleton/src/processes/create.process.ts

@@ -1,11 +1,11 @@
 import { ISkeletonProcess } from '../interfaces/skeleton-process.interface';
 
-export abstract class CreateProcess implements ISkeletonProcess {
+export class CreateProcess implements ISkeletonProcess {
-  abstract initialization();
+  async initialization(): Promise<any> {}
-  abstract before();
+  async before(): Promise<any> {}
-  abstract begin();
+  async begin(): Promise<any> {}
-  abstract process();
+  async process(): Promise<any> {}
-  abstract end();
+  async end(): Promise<any> {}
-  abstract after();
+  async after(): Promise<any> {}
-  abstract result();
+  async result(): Promise<any> {}
 }

libs/skeleton/src/processes/delete.process.ts

@@ -1,11 +1,11 @@
 import { ISkeletonProcess } from '../interfaces/skeleton-process.interface';
 
-export abstract class DeleteProcess implements ISkeletonProcess {
+export class DeleteProcess implements ISkeletonProcess {
-  abstract initialization();
+  async initialization(): Promise<any> {}
-  abstract before();
+  async before(): Promise<any> {}
-  abstract begin();
+  async begin(): Promise<any> {}
-  abstract process();
+  async process(): Promise<any> {}
-  abstract end();
+  async end(): Promise<any> {}
-  abstract after();
+  async after(): Promise<any> {}
-  abstract result();
+  async result(): Promise<any> {}
 }

libs/skeleton/src/processes/list.process.ts

@@ -1,11 +1,11 @@
 import { ISkeletonProcess } from '../interfaces/skeleton-process.interface';
 
 export abstract class ListProcess implements ISkeletonProcess {
-  abstract initialization();
+  async initialization(): Promise<any> {}
-  abstract before();
+  async before(): Promise<any> {}
-  abstract begin();
+  async begin(): Promise<any> {}
-  abstract process();
+  async process(): Promise<any> {}
-  abstract end();
+  async end(): Promise<any> {}
-  abstract after();
+  async after(): Promise<any> {}
-  abstract result();
+  async result(): Promise<any> {}
 }

libs/skeleton/src/processes/pagination.process.ts

@@ -1,11 +1,11 @@
 import { ISkeletonProcess } from '../interfaces/skeleton-process.interface';
 
 export abstract class PaginationProcess implements ISkeletonProcess {
-  abstract initialization();
+  async initialization(): Promise<any> {}
-  abstract before();
+  async before(): Promise<any> {}
-  abstract begin();
+  async begin(): Promise<any> {}
-  abstract process();
+  async process(): Promise<any> {}
-  abstract end();
+  async end(): Promise<any> {}
-  abstract after();
+  async after(): Promise<any> {}
-  abstract result();
+  async result(): Promise<any> {}
 }

libs/skeleton/src/processes/partial/batch/update.process.ts

@@ -1,11 +1,11 @@
 import { ISkeletonProcess } from '@autocrud/skeleton/interfaces/skeleton-process.interface';
 
 export abstract class PartialBatchUpdateProcess implements ISkeletonProcess {
-  abstract initialization();
+  async initialization(): Promise<any> {}
-  abstract before();
+  async before(): Promise<any> {}
-  abstract begin();
+  async begin(): Promise<any> {}
-  abstract process();
+  async process(): Promise<any> {}
-  abstract end();
+  async end(): Promise<any> {}
-  abstract after();
+  async after(): Promise<any> {}
-  abstract result();
+  async result(): Promise<any> {}
 }

libs/skeleton/src/processes/partial/update.process.ts

@@ -1,11 +1,11 @@
 import { ISkeletonProcess } from '@autocrud/skeleton/interfaces/skeleton-process.interface';
 
 export abstract class PartialUpdateProcess implements ISkeletonProcess {
-  abstract initialization();
+  async initialization(): Promise<any> {}
-  abstract before();
+  async before(): Promise<any> {}
-  abstract begin();
+  async begin(): Promise<any> {}
-  abstract process();
+  async process(): Promise<any> {}
-  abstract end();
+  async end(): Promise<any> {}
-  abstract after();
+  async after(): Promise<any> {}
-  abstract result();
+  async result(): Promise<any> {}
 }

libs/skeleton/src/processes/read.process.ts

@@ -1,11 +1,11 @@
 import { ISkeletonProcess } from '../interfaces/skeleton-process.interface';
 
 export abstract class ReadProcess implements ISkeletonProcess {
-  abstract initialization();
+  async initialization(): Promise<any> {}
-  abstract before();
+  async before(): Promise<any> {}
-  abstract begin();
+  async begin(): Promise<any> {}
-  abstract process();
+  async process(): Promise<any> {}
-  abstract end();
+  async end(): Promise<any> {}
-  abstract after();
+  async after(): Promise<any> {}
-  abstract result();
+  async result(): Promise<any> {}
 }

libs/skeleton/src/processes/update.process.ts

@@ -1,11 +1,11 @@
 import { ISkeletonProcess } from '../interfaces/skeleton-process.interface';
 
-export abstract class UpdateProcess implements ISkeletonProcess {
+export class UpdateProcess implements ISkeletonProcess {
-  abstract initialization();
+  async initialization(): Promise<any> {}
-  abstract before();
+  async before(): Promise<any> {}
-  abstract begin();
+  async begin(): Promise<any> {}
-  abstract process();
+  async process(): Promise<any> {}
-  abstract end();
+  async end(): Promise<any> {}
-  abstract after();
+  async after(): Promise<any> {}
-  abstract result();
+  async result(): Promise<any> {}
 }

libs/skeleton/src/skeleton-crud.controller.ts

@@ -1,4 +1,5 @@
 import { Delete, Get, Param, Patch, Post, Put } from '@nestjs/common';
+import { DefaultExecutor } from './executors/default.executor';
 import { ISkeletonCRUDController } from './interfaces/controller/skeleton-crud.controller.interface';
 
 export class SkeletonCRUDController implements ISkeletonCRUDController {
@@ -16,52 +17,52 @@ export class SkeletonCRUDController implements ISkeletonCRUDController {
   ) {}
 
   @Post()
-  async create() {
+  async create(): Promise<any> {
-    return this.createProcess.result();
+    return await DefaultExecutor.bootstrap(this.createProcess);
   }
 
   @Get(':id')
   async readSelected(@Param('id') id) {
-    return this.readProcess.result();
+    return await DefaultExecutor.bootstrap(this.readProcess);
   }
 
   @Get()
   async readPagination() {
-    return this.readPaginationProcess.result();
+    return await DefaultExecutor.bootstrap(this.readPaginationProcess);
   }
 
   @Get('list')
   async readEntire() {
-    return this.readEntireProcess.result();
+    return await DefaultExecutor.bootstrap(this.readEntireProcess);
   }
 
   @Patch()
   async updatePartial() {
-    return this.updatePartialProcess.result();
+    return await DefaultExecutor.bootstrap(this.updatePartialProcess);
   }
 
   @Patch('batch')
   async updatePartialBatch() {
-    return this.updateBatchProcess.result();
+    return await DefaultExecutor.bootstrap(this.updateBatchProcess);
   }
 
   @Put()
   async updateEntire() {
-    return this.updateEntireProcess.result();
+    return await DefaultExecutor.bootstrap(this.updateEntireProcess);
   }
 
   @Put('batch')
   async updateEntireBatch() {
-    return this.updateEntireBatchProcess.result();
+    return await DefaultExecutor.bootstrap(this.updateEntireBatchProcess);
   }
 
   @Delete()
   async deleteSelected() {
-    return this.deleteProcess.result();
+    return await DefaultExecutor.bootstrap(this.deleteProcess);
   }
 
   @Delete('batch')
   async deleteBatch() {
-    return this.deleteBatchProcess.result();
+    return await DefaultExecutor.bootstrap(this.deleteBatchProcess);
   }
 }