feat(model): add factory function, shareReplay perf, tests

tomastrajan · tomastrajan · commit 767a7fd73566 · 2019-07-19T11:19:17.000+02:00
- add factory function with config object which supports all config params
- use shareReplay({ bufferSize: 1, refCount: true }) to prevent memory leaks
- add tests
- update docs
diff --git a/README.md b/README.md
@@ -96,6 +96,7 @@ Multiple model factories are provided out of the box to support different use ca
 - `createMutable(initialData: T): Model<T>` - create model with no immutability guarantees (you have to make sure that model consumers don't mutate and corrupt model state) but much more performance because whole cloning step is skipped
 - `createMutableWithSharedSubscription(initialData: T): Model<T>` - gain even more performance by skipping both immutability and sharing subscription between all consumers (eg situation in which many components are subscribed to single model)
 - `createWithCustomClone(initialData: T, clone: (data: T) => T)` - create immutable model by passing your custom clone function (`JSON` cloning doesn't support properties containing function or regex so custom cloning functionality might be needed)
+- `createWithConfig(config)` - create model by passing in config object with values of all configuration properties (`initialData: T`, `immutable: boolean`, `sharedSubscription: boolean`, `clone: (data: T) => T`)
 
 ## Model Schematics API
 
diff --git a/lib/model/model.test.ts b/lib/model/model.test.ts
@@ -6,80 +6,91 @@ import { ModelFactory } from './model';
 const modelFactory = new ModelFactory<TestModel>();
 
 describe('Model', () => {
-  it('should be an immutable array', () => {
-    const factory: ModelFactory<TestModel[]> = new ModelFactory<TestModel[]>();
+  it('should expose model data in observable', () => {
+    const model = modelFactory.create({ value: 'test' });
 
-    const initial: TestModel[] = [];
-    const store = factory.create(initial);
+    model.data$.subscribe(data =>
+      assert.deepStrictEqual(data, { value: 'test' })
+    );
+  });
 
-    const initialState = store.get();
-    initialState.push({ value: 'updated' });
+  it('should expose raw data getter', () => {
+    const model = modelFactory.create({ value: 'test' });
 
-    assert.equal(store.get().length, 0);
+    assert.deepStrictEqual(model.get(), { value: 'test' });
   });
 
-  it('should be an immutable array after set', () => {
-    const factory: ModelFactory<TestModel[]> = new ModelFactory<TestModel[]>();
-
-    const initial: TestModel[] = [];
-    const store = factory.create(initial);
+  it('should expose raw data setter', () => {
+    const model = modelFactory.create(<TestModel>{ value: 'test' });
 
-    const updateArray = [{ value: 'first element' }];
-    store.set(updateArray);
+    model.set({ value: 'changed' });
 
-    updateArray.push({ value: '2nd element' });
-    assert.equal(store.get().length, 1);
+    assert.deepStrictEqual(model.get(), { value: 'changed' });
   });
 
-  it('should be immutable array on sub', () => {
-    const factory: ModelFactory<TestModel[]> = new ModelFactory<TestModel[]>();
-
-    const initial: TestModel[] = [];
-    const store = factory.create(initial);
-
-    const initialState = store.get();
-    initialState.push({ value: 'updated' });
+  it('should use immutable data in exposed observable by default', () => {
+    const model = modelFactory.create({ value: 'test' });
 
-    store.data$.subscribe(v => {
-      assert.equal(store.get().length, 0);
+    model.data$.subscribe(data => {
+      data.value = 'changed';
+      assert.deepStrictEqual(model.get(), { value: 'test' });
     });
   });
 
-  it('should expose model data in observable', () => {
+  it('should use immutable data in model by default (get)', () => {
     const model = modelFactory.create({ value: 'test' });
 
-    model.data$.subscribe(data => assert.deepEqual(data, { value: 'test' }));
+    const modelData = model.get();
+    modelData.value = 'changed';
+
+    model.data$.subscribe(data => {
+      assert.deepStrictEqual(data, { value: 'test' });
+    });
   });
 
-  it('should expose raw data getter', () => {
+  it('should use immutable data in model by default (set)', () => {
     const model = modelFactory.create({ value: 'test' });
 
-    assert.deepEqual(model.get(), { value: 'test' });
-  });
+    const changedData = { value: 'changed' };
+    model.set(changedData);
 
-  it('should expose raw data setter', () => {
-    const model = modelFactory.create(<TestModel>{ value: 'test' });
+    changedData.value = 'changed even more';
 
-    model.set({ value: 'changed' });
-
-    assert.deepEqual(model.get(), { value: 'changed' });
+    model.data$.subscribe(data => {
+      assert.deepStrictEqual(data, { value: 'changed' });
+    });
   });
 
-  it('should use immutable data in exposed observable by default', () => {
-    const model = modelFactory.create({ value: 'test' });
+  it('should use mutable data in exposed observable when configured', () => {
+    const model = modelFactory.createMutable({ value: 'test' });
 
     model.data$.subscribe(data => {
       data.value = 'changed';
-      assert.deepEqual(model.get(), { value: 'test' });
+      assert.deepStrictEqual(model.get(), { value: 'changed' });
     });
   });
 
-  it('should use mutable data in exposed observable when configured', () => {
+  it('should use mutable data in model (get) when configured', () => {
     const model = modelFactory.createMutable({ value: 'test' });
 
+    const modelData = model.get();
+    modelData.value = 'changed';
+
     model.data$.subscribe(data => {
-      data.value = 'changed';
-      assert.deepEqual(model.get(), { value: 'changed' });
+      assert.deepStrictEqual(data, { value: 'changed' });
+    });
+  });
+
+  it('should use mutable data in model (set) when configured', () => {
+    const model = modelFactory.createMutable({ value: 'test' });
+
+    const changedData = { value: 'changed' };
+    model.set(changedData);
+
+    changedData.value = 'changed even more';
+
+    model.data$.subscribe(data => {
+      assert.deepStrictEqual(data, { value: 'changed even more' });
     });
   });
 
@@ -96,15 +107,41 @@ describe('Model', () => {
     });
   });
 
+  it('should use custom clone function when configured (get)', () => {
+    const cloneSpy = sinon.spy();
+    const model = modelFactory.createWithCustomClone(
+      { value: 'test' },
+      cloneSpy
+    );
+
+    model.get();
+    sinon.assert.calledOnce(cloneSpy);
+    sinon.assert.calledWith(cloneSpy, { value: 'test' });
+  });
+
+  it('should use custom clone function when configured (set)', () => {
+    const cloneSpy = sinon.spy();
+    const model = modelFactory.createWithCustomClone(
+      { value: 'test' },
+      cloneSpy
+    );
+
+    model.set({ value: 'changed' });
+    sinon.assert.calledOnce(cloneSpy);
+    sinon.assert.calledWith(cloneSpy, { value: 'changed' });
+  });
+
   it('should create multiple independent instances', () => {
     const model1 = modelFactory.create({ value: 'test1' });
     const model2 = modelFactory.create({ value: 'test2' });
 
     model2.set({ value: 'changed' });
 
-    model1.data$.subscribe(data => assert.deepEqual(data, { value: 'test1' }));
+    model1.data$.subscribe(data =>
+      assert.deepStrictEqual(data, { value: 'test1' })
+    );
     model2.data$.subscribe(data =>
-      assert.deepEqual(data, { value: 'changed' })
+      assert.deepStrictEqual(data, { value: 'changed' })
     );
   });
 
@@ -113,10 +150,10 @@ describe('Model', () => {
 
     model.data$.subscribe(data => {
       data.value = 'changed';
-      assert.deepEqual(data, { value: 'changed' });
+      assert.deepStrictEqual(data, { value: 'changed' });
     });
     model.data$.subscribe(data => {
-      assert.deepEqual(data, { value: 'test' });
+      assert.deepStrictEqual(data, { value: 'test' });
     });
   });
 
@@ -127,10 +164,10 @@ describe('Model', () => {
 
     model.data$.subscribe(data => {
       data.value = 'changed';
-      assert.deepEqual(data, { value: 'changed' });
+      assert.deepStrictEqual(data, { value: 'changed' });
     });
     model.data$.subscribe(data => {
-      assert.deepEqual(data, { value: 'changed' });
+      assert.deepStrictEqual(data, { value: 'changed' });
     });
   });
 });
diff --git a/lib/model/model.ts b/lib/model/model.ts
@@ -22,7 +22,9 @@ export class Model<T> {
             : JSON.parse(JSON.stringify(data))
           : data
       ),
-      sharedSubscription ? shareReplay(1) : map((data: T) => data)
+      sharedSubscription
+        ? shareReplay({ bufferSize: 1, refCount: true })
+        : map((data: T) => data)
     );
   }
 
@@ -67,4 +69,14 @@ export class ModelFactory<T> {
   createWithCustomClone(initialData: T, clone: (data: T) => T) {
     return new Model<T>(initialData, true, false, clone);
   }
+
+  createWithConfig(config: {
+    initialData: T;
+    immutable: boolean;
+    sharedSubscription: boolean;
+    clone: (data: T) => T;
+  }) {
+    const { initialData, immutable, sharedSubscription, clone } = config;
+    return new Model<T>(initialData, immutable, sharedSubscription, clone);
+  }
 }
diff --git a/package.json b/package.json
@@ -10,7 +10,7 @@
     "build": "npm run clean && npm run lib:build && npm run schm:build",
     "coverage": "nyc report --reporter=text-lcov > coverage.lcov && codecov",
     "release": "npm run test && standard-version && git push --follow-tags origin master && npm run build && npm publish ./dist --access public",
-    "format": "prettier **/*.{ts,json,md} --write",
+    "format:write": "prettier **/*.{ts,json,md} --write",
     "format:test": "prettier **/*.{ts,json,md} --list-different",
     "lib:build": "ng-packagr -p package.json",
     "lib:test": "mocha lib/model/model.test.ts --require ts-node/register",
