fix(Entity): receive Props instead of id

BREAKING CHANGE: This change require props object always on Entity #4
almin · May 6, 2018 · ed135c8 · ed135c8
1 parent b10f387
commit ed135c8
Show file tree

Hide file tree

Showing 13 changed files with 270 additions and 132 deletions.
diff --git a/package.json b/package.json
@@ -47,14 +47,14 @@
   "devDependencies": {
     "@types/mocha": "^2.2.48",
     "@types/node": "^9.4.6",
-    "cross-env": "^5.1.3",
+    "cross-env": "^5.1.4",
     "husky": "^0.14.3",
     "lerna": "^2.9.0",
-    "lint-staged": "^7.0.0",
-    "mocha": "^5.0.4",
-    "prettier": "1.11.1",
-    "ts-node": "^5.0.1",
-    "typescript": "^2.7.2"
+    "lint-staged": "^7.0.5",
+    "mocha": "^5.1.1",
+    "prettier": "1.12.1",
+    "ts-node": "^6.0.2",
+    "typescript": "^2.8.3"
   },
   "dependencies": {
     "map-like": "^2.0.0",

diff --git a/src/Entity.ts b/src/Entity.ts
@@ -1,23 +1,31 @@
 // MIT © 2017 azu
 import { Identifier } from "./Identifier";
+import { EntityLike, EntityLikeProps } from "./EntityLike";
 
-export abstract class Entity<Id extends Identifier<any>> {
-    public readonly id: Id;
+export const isEntity = (v: any): v is Entity<any> => {
+    return v instanceof Entity;
+};
 
-    constructor(id: Id) {
-        this.id = id;
+export class Entity<Props extends EntityLikeProps<Identifier<any>>> implements EntityLike<Props> {
+    props: Props;
+
+    constructor(props: Props) {
+        this.props = props;
     }
 
-    /**
+    /*
      * Check equality by identifier
      */
-    equals(object?: Entity<Id>): boolean {
+    equals(object?: Entity<Props>): boolean {
         if (object == null || object == undefined) {
             return false;
         }
         if (this === object) {
             return true;
         }
-        return this.id.equals(object.id);
+        if (!isEntity(object)) {
+            return false;
+        }
+        return this.props.id.equals(object.props.id);
     }
 }
diff --git a/src/EntityLike.ts b/src/EntityLike.ts
@@ -0,0 +1,19 @@
+import { ImmutableEntity } from "./immutable/ImmutableEntity";
+import { Identifier } from "./Identifier";
+
+export const isEntityLike = (entity: any): entity is EntityLike<any> => {
+    if (!entity) {
+        return false;
+    }
+    return entity instanceof ImmutableEntity;
+};
+
+export interface EntityLikeProps<Id extends Identifier<any>> {
+    id: Id;
+}
+
+export interface EntityLike<Props extends EntityLikeProps<Identifier<any>>> {
+    props: Props;
+
+    equals(object?: EntityLike<Props>): boolean;
+}
diff --git a/src/immutable/ImmutableEntity.ts b/src/immutable/ImmutableEntity.ts
@@ -0,0 +1,41 @@
+// MIT © 2017 azu
+import { Identifier } from "../Identifier";
+import { EntityLike, EntityLikeProps } from "../EntityLike";
+
+export const isImmutableEntity = (entity: any): entity is ImmutableEntity<{ id: Identifier<any> }> => {
+    if (!entity) {
+        return false;
+    }
+    return entity instanceof ImmutableEntity;
+};
+
+/**
+ * ImmutableEntity is readonly Entity.
+ * It is created with Props and It has `props` property.
+ * This entity has received through constructor.
+ *
+ * @see https://www.quora.com/Why-did-React-use-props-as-an-abbreviation-for-property-properties
+ */
+export class ImmutableEntity<Props extends EntityLikeProps<Identifier<any>>> implements EntityLike<Props> {
+    props: Readonly<Props>;
+
+    constructor(props: Props) {
+        this.props = Object.freeze(props);
+    }
+
+    /*
+     * Check equality by identifier
+     */
+    equals(object?: ImmutableEntity<Props>): boolean {
+        if (object == null || object == undefined) {
+            return false;
+        }
+        if (this === object) {
+            return true;
+        }
+        if (!isImmutableEntity(object)) {
+            return false;
+        }
+        return this.props.id.equals(object.props.id);
+    }
+}
diff --git a/src/immutable/ImmutableValueObject.ts b/src/immutable/ImmutableValueObject.ts
@@ -0,0 +1,15 @@
+import { shallowEqual } from "shallow-equal-object";
+
+export class ImmutableValueObject<Props extends object> {
+    props: Readonly<Props>;
+    constructor(props: Props) {
+        this.props = Object.freeze(props);
+    }
+    /**
+     * Check equality by shallow equals of properties.
+     * It can be override.
+     */
+    equals(object?: ImmutableValueObject<{}>): boolean {
+        return shallowEqual(this, object);
+    }
+}
diff --git a/src/repository/NonNullableRepository.ts b/src/repository/NonNullableRepository.ts
@@ -1,45 +1,49 @@
 // MIT © 2017 azu
-import { Entity } from "../Entity";
 import { RepositoryCore } from "./RepositoryCore";
 import { MapLike } from "map-like";
 import { RepositoryEventEmitter } from "./RepositoryEventEmitter";
+import { EntityLike } from "../EntityLike";
 
 /**
  * NonNullableRepository has initial value.
  * In other words, NonNullableRepository#get always return a value.
  */
-export class NonNullableRepository<T extends Entity<any>> {
-    private core: RepositoryCore<T["id"], T>;
+export class NonNullableRepository<
+    Entity extends EntityLike<any>,
+    Props extends Entity["props"],
+    Id extends Props["id"]
+> {
+    private core: RepositoryCore<Entity, Props, Id>;
 
-    constructor(protected initialEntity: T) {
-        this.core = new RepositoryCore(new MapLike());
+    constructor(protected initialEntity: Entity) {
+        this.core = new RepositoryCore(new MapLike<string, Entity>());
     }
 
-    get map(): MapLike<string, T> {
+    get map(): MapLike<string, Entity> {
         return this.core.map;
     }
 
-    get events(): RepositoryEventEmitter<T> {
+    get events(): RepositoryEventEmitter<Entity> {
         return this.core.events;
     }
 
-    get(): T {
+    get(): Entity {
         return this.core.getLastSaved() || this.initialEntity;
     }
 
-    getAll(): T[] {
+    getAll(): Entity[] {
         return this.core.getAll();
     }
 
-    findById(entityId?: T["id"]): T | undefined {
+    findById(entityId?: Id): Entity | undefined {
         return this.core.findById(entityId);
     }
 
-    save(entity: T): void {
+    save(entity: Entity): void {
         this.core.save(entity);
     }
 
-    delete(entity: T) {
+    delete(entity: Entity) {
         this.core.delete(entity);
     }
 

diff --git a/src/repository/NullableRepository.ts b/src/repository/NullableRepository.ts
@@ -1,45 +1,45 @@
 // MIT © 2017 azu
-import { Entity } from "../Entity";
 import { RepositoryCore } from "./RepositoryCore";
 import { MapLike } from "map-like";
 import { RepositoryEventEmitter } from "./RepositoryEventEmitter";
+import { EntityLike } from "../EntityLike";
 
 /**
  * NullableRepository has not initial value.
  * In other word, NullableRepository#get may return undefined.
  */
-export class NullableRepository<T extends Entity<any>> {
-    private core: RepositoryCore<T["id"], T>;
+export class NullableRepository<Entity extends EntityLike<any>, Props extends Entity["props"], Id extends Props["id"]> {
+    private core: RepositoryCore<Entity, Props, Id>;
 
     constructor() {
         this.core = new RepositoryCore(new MapLike());
     }
 
-    get map(): MapLike<string, T> {
+    get map(): MapLike<string, Entity> {
         return this.core.map;
     }
 
-    get events(): RepositoryEventEmitter<T> {
+    get events(): RepositoryEventEmitter<Entity> {
         return this.core.events;
     }
 
-    get(): T | undefined {
+    get(): Entity | undefined {
         return this.core.getLastSaved();
     }
 
-    getAll(): T[] {
+    getAll(): Entity[] {
         return this.core.getAll();
     }
 
-    findById(entityId?: T["id"]): T | undefined {
+    findById(entityId?: Id): Entity | undefined {
         return this.core.findById(entityId);
     }
 
-    save(entity: T): void {
+    save(entity: Entity): void {
         this.core.save(entity);
     }
 
-    delete(entity: T) {
+    delete(entity: Entity) {
         this.core.delete(entity);
     }
 

diff --git a/src/repository/RepositoryCore.ts b/src/repository/RepositoryCore.ts
@@ -1,36 +1,39 @@
 // MIT © 2017 azu
-import { Entity } from "../Entity";
 import { MapLike } from "map-like";
-import { Identifier } from "../Identifier";
 import { RepositoryDeletedEvent, RepositoryEventEmitter, RepositorySavedEvent } from "./RepositoryEventEmitter";
+import { EntityLike } from "../EntityLike";
 
 /**
  * Repository Core implementation
  */
-export class RepositoryCore<T extends Identifier<any>, P extends Entity<T>> {
-    public readonly map: MapLike<string, P>;
-    public readonly events: RepositoryEventEmitter<P>;
-    private lastUsed: P | undefined;
+export class RepositoryCore<
+    Entity extends EntityLike<any>,
+    Props extends Entity["props"] = Entity["props"],
+    Id extends Props["id"] = Props["id"]
+> {
+    public readonly map: MapLike<string, Entity>;
+    public readonly events: RepositoryEventEmitter<Entity>;
+    private lastUsed: Entity | undefined;
 
-    constructor(map: MapLike<string, P>) {
+    constructor(map: MapLike<string, Entity>) {
         this.map = map;
-        this.events = new RepositoryEventEmitter<P>();
+        this.events = new RepositoryEventEmitter<Entity>();
     }
 
     /**
      * Get last saved entity if exist.
      * This is useful on client-side implementation.
      * Because, client-side often access-user is a single user.
      */
-    getLastSaved(): P | undefined {
+    getLastSaved(): Entity | undefined {
         return this.lastUsed;
     }
 
     /**
      * Find a entity by `entityIdentifier` that is instance of Identifier class.
      * Return `undefined` if not found entity.
      */
-    findById(entityIdentifier?: T): P | undefined {
+    findById(entityIdentifier?: Id): Entity | undefined {
         if (!entityIdentifier) {
             return;
         }
@@ -40,31 +43,31 @@ export class RepositoryCore<T extends Identifier<any>, P extends Entity<T>> {
     /**
      * Find all entity that `predicate(entity)` return true
      */
-    findAll(predicate: (entity: P) => boolean): P[] {
+    findAll(predicate: (entity: Entity) => boolean): Entity[] {
         return this.map.values().filter(predicate);
     }
 
     /**
      * Get all entities
      */
-    getAll(): P[] {
+    getAll(): Entity[] {
         return this.map.values();
     }
 
     /**
      * Save entity to the repository.
      */
-    save(entity: P): void {
+    save(entity: Entity): void {
         this.lastUsed = entity;
-        this.map.set(String(entity.id.toValue()), entity);
+        this.map.set(String(entity.props.id.toValue()), entity);
         this.events.emit(new RepositorySavedEvent(entity));
     }
 
     /**
      * Delete entity from the repository.
      */
-    delete(entity: P) {
-        this.map.delete(String(entity.id.toValue()));
+    delete(entity: Entity) {
+        this.map.delete(String(entity.props.id.toValue()));
         if (this.lastUsed === entity) {
             delete this.lastUsed;
         }
@@ -74,7 +77,7 @@ export class RepositoryCore<T extends Identifier<any>, P extends Entity<T>> {
     /**
      * Delete entity by `entityIdentifier` that is instance of Identifier class.
      */
-    deleteById(entityIdentifier?: T) {
+    deleteById(entityIdentifier?: Id) {
         if (!entityIdentifier) {
             return;
         }

diff --git a/src/repository/RepositoryEventEmitter.ts b/src/repository/RepositoryEventEmitter.ts
@@ -1,6 +1,7 @@
 // MIT © 2017 azu
 import { EventEmitter } from "events";
 import { Entity } from "../Entity";
+import { EntityLike } from "../EntityLike";
 
 const SAVE = "SAVE";
 const DELETE = "DELETE";
@@ -19,7 +20,7 @@ export class RepositoryDeletedEvent<T> {
 
 export type RepositoryEvents<T = Entity<any>> = RepositorySavedEvent<T> | RepositoryDeletedEvent<T>;
 
-export class RepositoryEventEmitter<T extends Entity<any>> {
+export class RepositoryEventEmitter<T extends EntityLike<any>> {
     private eventEmitter: EventEmitter;
 
     constructor() {