making update method internal

README.md

@@ -28,32 +28,32 @@ export class Foo {
 Next, we need to create an implementation of the base "RepositoryContext" class:
 
 ```ts
-//file: sample-repository.ts
+//file: sample-context.ts
 import { RepositoryContext, Repository } from 'json-repo';
 import { Foo } from './foo';
 
-export class SampleRepository extends RepositoryContext {
+export class SampleDataContext extends RepositoryContext {
   constructor(dataPath: string) { super(dataPath); }
   models = {
     baz: new Repository<Foo>()
   }
 }
 ```
 
-Finally, we need to initialize the repository in our application:
+Finally, we need to initialize the context in our application:
 
 ```ts
 import * as path from 'path';
-import { SampleRepository } from './sample-repository';
+import { SampleDataContext } from './sample-context';
 import { Foo } from './foo';
 
 const jsonFilePath = path.join(__dirname, 'db.json');
-let repository = new SampleRepository(jsonFilePath);
-repository.initialize().then(_ => {
-  //you can now use the repository
+let context = new SampleDataContext(jsonFilePath);
+context.initialize().then(_ => {
+  //you can now use the context
   let foo = new Foo(); foo.bar = 'baz';
-  repository.models.baz.add('1', foo);
-  return repository.saveChanges();
+  context.models.baz.add('1', foo);
+  return context.saveChanges();
 });
 ```
 
@@ -69,7 +69,7 @@ The "RepositoryContext" is an abstract class that allows you to communicate with
 //provided from the repository-context.d.ts file
 export declare abstract class RepositoryContext {
   abstract models: {
-    [key: string]: Repository<any>;
+    [key: string]: IRepository<any>;
   };
   constructor(dataPath?: string, entityNodeService?: IEntityNodeService);
   initialize: () => Promise<void>;
@@ -87,25 +87,25 @@ export declare abstract class RepositoryContext {
 
 #### Repository
 
-The "Repository" class is a generic class, with the type argument representing a domain object. Some built-in methods are provided to manage and query the repository; this class can also be extended, if you wish to provide additional functionality. 
+The "Repository" interface is defined as a generic, with the type argument representing a domain object. Some built-in methods are provided to manage and query the repository. The default implementation of IRepository is Repository, and can also be extended if you wish to provide additional functionality. 
 
 ```ts
 //provided from the repository.d.ts file
 export declare class Repository<T> {
-    get state(): string;
-    protected _state: string;
-    protected data: {
-        [key: string]: T;
-    };
-    load: (data: EntityNode[]) => void;
-    extract: () => EntityNode[];
-    find: (key: string) => T;
-    where: (filter: (item: T) => boolean) => T[];
-    add: (key: string, item: T) => void;
-    upsert: (key: string, item: T) => void;
-    update: (key: string, item: T) => void;
-    delete: (key: string) => void;
-    markCurrent: () => void;
+  get state(): string;
+  protected _state: string;
+  protected data: {
+      [key: string]: T;
+  };
+  load: (data: EntityNode[]) => void;
+  extract: () => EntityNode[];
+  find: (key: string) => T;
+  filter: (filter: (item: T) => boolean) => T[];
+  add: (key: string, item: T) => void;
+  addRange: (items: [{key: string, item: T}]) => void;
+  update: (key: string, action: (item: T) => T) => void;
+  delete: (key: string) => void;
+  markCurrent: () => void;
 }
 ```
 
@@ -115,17 +115,18 @@ An "EntityNode" is the core persistent storage block of a repository. When files
 ```ts
 //provided from the entity-node.d.ts file
 export declare class EntityNode {
-    key: string;
-    value: any;
+  key: string;
+  value: any;
 }
 ```
 
 #### IEntityNodeService
 The implementation of "IEntityNodeService" acts as the persistent storage layer, reading to and writing from some storage mechanism. The built-in implementation of IEntityNodeService is calls "JsonFileService", and is provided by default to all "RepositoryContext" objects. If you wish to provide a custom data persistence solution, you can achieve this by creating a custom implementation of IEntityNodeService.
 
 ```ts
+//provided from the entity-node-service.d.ts file
 export interface IEntityNodeService {
-    getEntityNodes(path: string): Promise<{[model: string]: EntityNode[];}>;
-    persistEntityNodes<T>(path: string, data: T): Promise<void>;
+  getEntityNodes(path: string): Promise<{[model: string]: EntityNode[];}>;
+  persistEntityNodes<T>(path: string, data: T): Promise<void>;
 }
 ```

package.json

@@ -1,6 +1,6 @@
 {
   "name": "json-repo",
-  "version": "1.1.3",
+  "version": "1.2.1",
   "description": "Read and write data to JSON files using the repository pattern. ",
   "scripts": {
     "test": "nyc mocha",

src/repository-context.spec.ts

@@ -63,7 +63,7 @@ describe('ContextBase', () => {
     jsonService.persistEntityNodes.returns(Promise.resolve(sampleData));
     let context = new NoopContextBase("inmemory", jsonService);
     context.initialize().then(_ => {
-      context.models.sample.update('1', new SampleData());
+      context.models.sample.update('1', (item => item));
       return context.saveChanges()
     })
     .then(_ => {

src/repository-context.ts

@@ -1,11 +1,11 @@
 import { JsonFileService } from "./json-file-service";
 import { IEntityNodeService } from './entity-node-service';
 import { EntityNode } from "./entity-node";
-import { Repository } from "./repository";
+import { IRepository } from "./repository";
 
 export abstract class RepositoryContext {
 
-  abstract models: {[model: string]: Repository<any>};
+  abstract models: {[model: string]: IRepository<any>};
   private dataPath: string;
   private entityNodeService: IEntityNodeService;
 

src/repository.spec.ts

@@ -20,19 +20,19 @@ describe('Repository', () => {
     expect(repository.state).to.equal('current');
   });
 
-  it('get should return entities', () => {
+  it('extract should return entities', () => {
     repository.load([{key: '1', value: new SampleData()}]);
     expect(repository.extract().length).to.equal(1);
   });
 
-  it('where should return values that match filter', () => {
+  it('filter should return values that match filter', () => {
     let sample = [
       {key: '1', value: new SampleData()},
       {key: '2', value: new SampleData()}
     ];
     sample[0].value.foo = 'foo1';
     repository.load(sample);
-    let result = repository.where(item => item.foo == 'foo1');
+    let result = repository.filter(item => item.foo == 'foo1');
     expect(result.length).to.equal(1);
   });
 
@@ -51,6 +51,14 @@ describe('Repository', () => {
     expect(() => { repository.add('1', new SampleData()); }).to.throw();
   });
 
+  it('addRange should add multiple items', () => {
+    repository.addRange([
+      {key: '1', value: new SampleData()},
+      {key: '2', value: new SampleData()}
+    ]);
+    expect(repository.extract().length).to.equal(2);
+  })
+
   it('markCurrent should set state to current', () => {
     repository.add('1', new SampleData());
     repository.markCurrent();
@@ -62,41 +70,44 @@ describe('Repository', () => {
   });
 
   it('find should return value if key exists', () => {
-    repository.upsert('1', new SampleData());
+    repository.add('1', new SampleData());
     expect(repository.find('1')).not.to.be.undefined;
   });
 
-  it('upsert should create new entity', () => {
-    repository.upsert('1', new SampleData());
-    expect(repository.find('1')).not.to.be.undefined;
+  it('update should throw error when key does not exist', () => {
+    expect(() => { repository.update('1', (item => item)); }).to.throw();
   });
 
-  it('upsert should update existing entity', () => {
+  it('update should update existing entity', () => {
     repository.load([{key: '1', value: new SampleData()}]);
-    let newValue = new SampleData(); newValue.foo = 'baz';
-    repository.upsert('1', newValue);
-    expect(repository.find('1').foo).to.equal('baz');
+    repository.update('1', (item => {
+      item.foo = 'baz'; return item;
+    }));
+    expect(repository.find('1')).not.to.be.undefined;
   });
 
-  it('upsert should set state to dirty', () => {
-    repository.upsert('1', new SampleData());
+  it('update should set state to dirty', () => {
+    repository.load([{key: '1', value: new SampleData()}]);
+    repository.update('1', (item => {
+      item.foo = 'baz'; return item;
+    }));
     expect(repository.state).to.equal('dirty');
   });
 
-  it('update should throw error when key does not exist', () => {
-    expect(() => { repository.update('1', new SampleData()); }).to.throw();
+  it('upsert should create new entity', () => {
+    repository.upsert('1', new SampleData());
+    expect(repository.find('1')).not.to.be.undefined;
   });
 
-  it('update should update existing entity', () => {
+  it('upsert should update existing entity', () => {
     repository.load([{key: '1', value: new SampleData()}]);
     let newValue = new SampleData(); newValue.foo = 'baz';
-    repository.update('1', newValue);
-    expect(repository.find('1')).not.to.be.undefined;
+    repository.upsert('1', newValue);
+    expect(repository.find('1').foo).to.equal('baz');
   });
 
-  it('update should set state to dirty', () => {
-    repository.load([{key: '1', value: new SampleData()}]);
-    repository.update('1', new SampleData());
+  it('upsert should set state to dirty', () => {
+    repository.upsert('1', new SampleData());
     expect(repository.state).to.equal('dirty');
   });
 

src/repository.ts

@@ -1,6 +1,19 @@
 import { EntityNode } from './entity-node';
 
-export class Repository<T> {
+export interface IRepository<T> {
+  state: string;
+  load: (data: EntityNode[]) => void;
+  extract: () => EntityNode[];
+  find: (key: string) => T;
+  filter: (filter: (item: T) => boolean) => T[];
+  add: (key: string, item: T) => void;
+  addRange: (items: {key: string, value: T}[]) => void;
+  update: (key: string, action: (item: T) => T) => void;
+  delete: (key: string) => void;
+  markCurrent: () => void;
+}
+
+export class Repository<T> implements IRepository<T> {
 
   get state(): string { return this._state; };
   protected _state: string = 'unset';
@@ -23,7 +36,7 @@ export class Repository<T> {
     return this.data[key];
   }
 
-  where = (filter: (item: T) => boolean): T[] => {
+  filter = (filter: (item: T) => boolean): T[] => {
     return this.extract().map(rslt => rslt.value).filter(filter);
   }
 
@@ -33,13 +46,19 @@ export class Repository<T> {
     this._state = 'dirty';
   }
 
-  upsert = (key: string, item: T) => {
-    this.data[key] = item;
-    this._state = 'dirty';
+  addRange = (items: {key: string, value: T}[]) => {
+    for (var i = 0; i < items.length; i++) {
+      this.add(items[i].key, items[i].value);
+    }
   }
 
-  update = (key: string, item: T) => {
+  update = (key: string, action: (item: T) => T) => {
     if (!this.data[key]) throw new Error(`Item with key '${key}' does not exist.`);
+    this.data[key] = action(this.data[key]);
+    this._state = 'dirty';
+  }
+
+  upsert = (key: string, item: T) => {
     this.data[key] = item;
     this._state = 'dirty';
   }