refactoring: refactor

Author: FilipeMata

env/development.env

@@ -2,5 +2,5 @@
 NODE_ENV=development
 
 # Server
-PORT=3000
+PORT=7000
 HOST=localhost

src/adapters/gateways/base-gateway.ts

@@ -1,20 +1,66 @@
-import { UnitOfWork, Entity } from '@entities';
+import { Entity, UniqueEntityID } from '@entities';
+import MapperRegistry from '../../entities/mapper-registry';
+import { UnitOfWork } from './unit-of-work';
 
-export default interface Repository<T> {
-  remove(t: T): Promise<void>;
-  removeCollection(t: T): Promise<void>;
-  save(t: T): Promise<void>;
-  saveCollection(t: Array<T>): Promise<void>
+export interface Gateway {
+  startTransaction(): void;
+  abstractFindAll(entityName: string, criteria: any): Promise<Entity<any>[]>;
+  abstractFind(entityName: string, id: UniqueEntityID): Promise<Entity<any>>;
+  endTransaction(): void;
+  remove(e: Entity<any>): Promise<void>;
+  removeCollection(entities: Entity<any>[]): Promise<void>;
+  save(e: Entity<any>): Promise<void>;
+  saveCollection(entities: Entity<any>[]): Promise<void>
 }
 
-export class BaseGateway {
+export class BaseGateway implements Gateway {
   private uow: UnitOfWork | undefined;
 
   public startTransaction() {
     this.uow = new UnitOfWork();
   }
 
-  public save(e: Entity<any>) {
+  public async abstractFind(entityName: string, id: UniqueEntityID): Promise<Entity<any>> {
+    let entity = this.uow.load(entityName, id);
+
+    if(!entity) {
+      entity = await MapperRegistry.getEntiyMapper(entityName).find({id: id.toValue()});
+    }
+
+    if(!entity) {
+      return null;
+    }
+
+    this.uow.registerClean(entity);
+    return entity;
+  }
+
+  public async abstractFindAll(entityName: string, criteria: any): Promise<Entity<any>[]> {
+    const reload = (entity: Entity<any>) => {
+      if (!this.uow) 
+        entity;
+
+      const loaded = this.uow.load(entityName, entity.id);
+
+      if (!loaded) {
+        this.uow.registerClean(loaded);
+        return entity;
+      }
+
+      return loaded;
+    }
+
+    let entities = await MapperRegistry.getEntiyMapper(entityName).findAll(criteria);
+    
+    for (let i = 0; i < entities.length; i++) {
+      entities[i] = reload(entities[i]);
+    }
+    
+    return entities;
+  }
+
+
+  public async save(e: Entity<any>) {
     if (this.uow.isNew(e) || this.uow.isClean(e)) {
       this.uow.registerDirty(e);
       return;
@@ -23,17 +69,17 @@ export class BaseGateway {
     this.uow.registerNew(e);
   }
 
-  public saveCollection(entities: Entity<any>[]) {
+  public async saveCollection(entities: Entity<any>[]) {
     for (const e of entities) {
       this.save(e);
     }
   } 
 
-  public remove(e: Entity<any>) {
+  public async remove(e: Entity<any>) {
     this.uow.registerRemoved(e);
   }
 
-  public removeCollection(entities: Entity<any>[]) {
+  public async removeCollection(entities: Entity<any>[]) {
     for (const e of entities) {
       this.remove(e);
     }
@@ -43,5 +89,4 @@ export class BaseGateway {
     await this.uow.commit();
     this.uow = undefined;
   }
-
 }

src/adapters/gateways/decorators/customer-decorator.ts

@@ -0,0 +1,9 @@
+import { Customer, UniqueEntityID } from '@entities';
+import GatewayDecorator from './gateway-decorator';
+
+export default class CustomerDecorator extends GatewayDecorator {
+  public async findCustomerById(customerId: UniqueEntityID): Promise<Customer> {
+    const customer = await this.abstractFind('Customer', customerId);
+    return customer as Customer;
+  }
+}

src/adapters/gateways/decorators/gateway-decorator.ts

@@ -0,0 +1,43 @@
+
+import { UniqueEntityID, Entity } from '@entities';
+import { Gateway } from '../base-gateway';
+
+export default class GatewayDecorator implements Gateway {
+  protected _baseGateway: Gateway;
+
+  constructor(gateway: Gateway) {
+    this._baseGateway = gateway;
+  }
+
+  public async abstractFindAll(entity: string, criteria: any): Promise<Entity<any>[]> {
+    return this._baseGateway.abstractFindAll(entity, criteria);
+  }
+
+  public async abstractFind(entity: string, id: UniqueEntityID) {
+    return this._baseGateway.abstractFind(entity, id);
+  }
+
+  public startTransaction() {
+    this._baseGateway.startTransaction();
+  }
+
+  public async save(e: Entity<any>) {
+    this._baseGateway.save(e);
+  }
+
+  public async saveCollection(entities: Entity<any>[]) {
+    this._baseGateway.saveCollection(entities);
+  }
+
+  public async remove(e: Entity<any>) {
+    this._baseGateway.remove(e);
+  }
+
+  public async removeCollection(entities: Entity<any>[]) {
+    this._baseGateway.removeCollection(entities);
+  }
+
+  public async endTransaction() {
+    this._baseGateway.endTransaction();
+  }
+}

src/adapters/gateways/decorators/oder-decorator.ts

@@ -0,0 +1,9 @@
+import { Order, UniqueEntityID } from '@entities';
+import GatewayDecorator from './gateway-decorator';
+
+export default class OrderDecorator extends GatewayDecorator {
+  public async findOrderById(orderId: UniqueEntityID): Promise<Order> {
+    const order = await this.abstractFind('Order', orderId);
+    return order as Order;
+  }
+}

src/adapters/gateways/decorators/product-decorator.rep.ts

@@ -0,0 +1,9 @@
+import { Product, UniqueEntityID } from '@entities';
+import GatewayDecorator from './gateway-decorator';
+
+export default class ProductDecorator extends GatewayDecorator {
+  public async findProductById(productId: UniqueEntityID): Promise<Product> {
+    const product = await this.abstractFind('Product', productId);
+    return product as Product;
+  }
+}

src/adapters/gateways/detail-order.gateway.ts

@@ -1,46 +1,15 @@
 import DetailOrderGateway from '../../application/use-cases/detail-order/detail-order.gateway';
-import { UniqueEntityID } from '@entities';
-import { Customer, Order, Product} from '@entities';
+import { Gateway, BaseGateway } from './base-gateway';
+import CustomerDecorator from './decorators/customer-decorator';
+import ProductDecorator from './decorators/product-decorator.rep';
+import OrderDecorator from './decorators/oder-decorator';
 
 
-interface CustomerRepositoryForDetailOrder {
-  getCustomerById(customerId: UniqueEntityID): Promise<Customer>
-};
+let baseGateway: DetailOrderGateway;
+const g1 = new BaseGateway();
+const g2 = new CustomerDecorator(g1);
+const g3 = new ProductDecorator(g2);
+baseGateway = new OrderDecorator(g3);
 
-interface ProductRepositoryForDetailOrder {
-  getProductById(productId: UniqueEntityID): Promise<Product>
-};
+detailOrderGateway.fin
 
-
-interface OrderRepositoryForDetailOrder {
-  getOrderById(customerId: UniqueEntityID): Promise<Order>
-};
-
-
-export default class DetailOrderGatewayImpl implements DetailOrderGateway {
-  private _customerRep: CustomerRepositoryForDetailOrder;
-  private _productRep: ProductRepositoryForDetailOrder;
-  private _orderRep: OrderRepositoryForDetailOrder;
-
-  constructor(
-    customerRep: CustomerRepositoryForDetailOrder,
-    productRep: ProductRepositoryForDetailOrder,
-    orderRep: OrderRepositoryForDetailOrder
-  ) {
-    this._customerRep = customerRep;
-    this._productRep = productRep;
-    this._orderRep = orderRep;
-  }
-  
-  async getCustomerById(customerId: UniqueEntityID): Promise<Customer> {
-    return this._customerRep.getCustomerById(customerId);
-  };
-
-  getProductById(productId: UniqueEntityID): Promise<Product> {
-    return this._productRep.getProductById(productId);
-  }
-
-  getOrderById(orderId: UniqueEntityID): Promise<Order> {
-    return this._orderRep.getOrderById(orderId);
-  }
-}