wip: base process

libs/skeleton/src/interfaces/skeleton-process.interface.ts

@@ -1,10 +1,10 @@
-import { Observable } from 'rxjs';
+export interface ISkeletonProcess<T, R> {
+  initialization(): T;
+  before(): T;
+  begin(): T;
+  process(): T;
+  end(): T;
+  after(): T;
 
-export interface SkeletonProcess {
+  result(): R;
-  initialization(): Observable<void>;
-  before(): Observable<void>;
-  begin(): Observable<void>;
-  process(): Observable<void>;
-  end(): Observable<void>;
-  after(): Observable<void>;
 }

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

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

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

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

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

@@ -1,30 +1,11 @@
-import { Observable, of } from 'rxjs';
+import { ISkeletonProcess } from '../interfaces/skeleton-process.interface';
-import { SkeletonProcess } from '../interfaces/skeleton-process.interface';
 
-export class CreateProcess implements SkeletonProcess {
+export abstract class CreateProcess<T, R> implements ISkeletonProcess<T, R> {
-  constructor() {}
+  abstract initialization(): T;
-
+  abstract before(): T;
-  initialization(): Observable<void> {
+  abstract begin(): T;
-    return of(undefined);
+  abstract process(): T;
-  }
+  abstract end(): T;
-
+  abstract after(): T;
-  before(): Observable<void> {
+  abstract result(): R;
-    return of(undefined);
-  }
-
-  begin(): Observable<void> {
-    return of(undefined);
-  }
-
-  process(): Observable<void> {
-    return of(undefined);
-  }
-
-  end(): Observable<void> {
-    return of(undefined);
-  }
-
-  after(): Observable<void> {
-    return of(undefined);
-  }
 }

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,57 +1,90 @@
 import { Delete, Get, Param, Patch, Post, Put } from '@nestjs/common';
-import { ISkeletonCRUDController } from './interfaces/controller/skeleton-crud.controller.interface';
 import { IPaginationEntity } from './entities/pagination.entity';
+import { ISkeletonCRUDController } from './interfaces/controller/skeleton-crud.controller.interface';
+import { BatchDeleteProcess } from './processes/batch/delete.process';
+import { BatchUpdateProcess } from './processes/batch/update.process';
+import { CreateProcess } from './processes/create.process';
+import { DeleteProcess } from './processes/delete.process';
+import { ListProcess } from './processes/list.process';
+import { PaginationProcess } from './processes/pagination.process';
+import { PartialBatchUpdateProcess } from './processes/partial/batch/update.process';
+import { ReadProcess } from './processes/read.process';
+import { UpdateProcess } from './processes/update.process';
 
-export class SkeletonCRUDController<T, E>
+export class SkeletonCRUDController<
-  implements ISkeletonCRUDController<T, E>
+  T,
+  E,
+  CP extends CreateProcess<T, T>,
+  RSP extends ReadProcess<T, T>,
+  RPP extends PaginationProcess<T, IPaginationEntity<T>>,
+  REP extends ListProcess<T, T[]>,
+  UPP extends UpdateProcess<T, T>,
+  UBP extends PartialBatchUpdateProcess<T, T[]>,
+  UEP extends UpdateProcess<T, T>,
+  UEBP extends BatchUpdateProcess<T, T[]>,
+  DP extends DeleteProcess<T, T>,
+  DBP extends BatchDeleteProcess<T, T[]>,
+> implements ISkeletonCRUDController<T, E>
 {
+  constructor(
+    private readonly createProcess: CP,
+    private readonly readProcess: RSP,
+    private readonly readPaginationProcess: RPP,
+    private readonly readEntireProcess: REP,
+    private readonly updatePartialProcess: UPP,
+    private readonly updateBatchProcess: UBP,
+    private readonly updateEntireProcess: UEP,
+    private readonly updateEntireBatchProcess: UEBP,
+    private readonly deleteProcess: DP,
+    private readonly deleteBatchProcess: DBP,
+  ) {}
   @Post()
   async create(): Promise<T> {
-    throw new Error('Method not implemented.');
+    return this.createProcess.result();
   }
 
   @Get(':id')
   async readSelected(@Param('id') id: E): Promise<T> {
-    throw new Error('Method not implemented.');
+    return this.readProcess.result();
   }
 
   @Get()
   async readPagination(): Promise<IPaginationEntity<T>> {
-    throw new Error('Method not implemented.');
+    return this.readPaginationProcess.result();
   }
 
   @Get('list')
   async readEntire(): Promise<T[]> {
-    throw new Error('Method not implemented.');
+    return this.readEntireProcess.result();
   }
 
   @Patch()
   async updatePartial(): Promise<T> {
-    throw new Error('Method not implemented.');
+    return this.updatePartialProcess.result();
   }
 
   @Patch('batch')
   async updatePartialBatch(): Promise<T[]> {
-    throw new Error('Method not implemented.');
+    return this.updateBatchProcess.result();
   }
 
   @Put()
   async updateEntire(): Promise<T> {
-    throw new Error('Method not implemented.');
+    return this.updateEntireProcess.result();
   }
 
   @Put('batch')
   async updateEntireBatch(): Promise<T[]> {
-    throw new Error('Method not implemented.');
+    return this.updateEntireBatchProcess.result();
   }
 
   @Delete()
   async deleteSelected(): Promise<T> {
-    throw new Error('Method not implemented.');
+    return this.deleteProcess.result();
   }
 
   @Delete('batch')
   async deleteBatch(): Promise<T[]> {
-    throw new Error('Method not implemented.');
+    return this.deleteBatchProcess.result();
   }
 }