Merge pull request #197 from orbitjs/update-store

Modernize and standardize Store + Cache interfaces

Author: dgeb

addon/-private/cache.ts

@@ -1,24 +1,25 @@
 import { notifyPropertyChange } from '@ember/object';
-
 import { Listener } from '@orbit/core';
 import { deepGet } from '@orbit/utils';
 import Orbit, {
   buildQuery,
   RecordIdentity,
   QueryOrExpression,
   RecordOperation,
-  Record
+  Record,
+  KeyMap,
+  Schema,
+  TransformBuilder
 } from '@orbit/data';
 import { QueryResultData } from '@orbit/record-cache';
 import { MemoryCache } from '@orbit/memory';
 import IdentityMap from '@orbit/identity-map';
-
 import LiveQuery from './live-query';
 import Model from './model';
 import ModelFactory from './model-factory';
 import recordIdentitySerializer from './utils/record-identity-serializer';
 
-const { deprecate } = Orbit;
+const { assert, deprecate } = Orbit;
 
 export interface CacheSettings {
   sourceCache: MemoryCache;
@@ -50,34 +51,127 @@ export default class Cache {
     this._sourceCache.on('reset', this._resetListener);
   }
 
+  get keyMap(): KeyMap | undefined {
+    return this._sourceCache.keyMap;
+  }
+
+  get schema(): Schema {
+    return this._sourceCache.schema;
+  }
+
+  get transformBuilder(): TransformBuilder {
+    return this._sourceCache.transformBuilder;
+  }
+
+  /**
+   * @deprecated
+   */
   retrieveRecordData(type: string, id: string): Record | undefined {
+    deprecate(
+      '`Cache#retrieveRecordData(type, id)` is deprecated, use `Cache#peekRecordData(type, id)`.'
+    );
+    return this.peekRecordData(type, id);
+  }
+
+  peekRecordData(type: string, id: string): Record | undefined {
     return this._sourceCache.getRecordSync({ type, id });
   }
 
   includesRecord(type: string, id: string): boolean {
-    return !!this.retrieveRecordData(type, id);
+    return !!this.peekRecordData(type, id);
   }
 
+  /**
+   * @deprecated
+   */
   retrieveRecord(type: string, id: string): Model | undefined {
+    deprecate(
+      '`Cache#retrieveRecord(type, id)` is deprecated, use `Cache#peekRecord(type, id)`.'
+    );
+    return this.peekRecord(type, id);
+  }
+
+  peekRecord(type: string, id: string): Model | undefined {
     if (this.includesRecord(type, id)) {
       return this.lookup({ type, id }) as Model;
     }
     return undefined;
   }
 
+  peekRecords(type: string): Model[] {
+    const identities = this._sourceCache.getRecordsSync(type);
+    return this.lookup(identities) as Model[];
+  }
+
+  peekRecordByKey(
+    type: string,
+    keyName: string,
+    keyValue: string
+  ): Model | undefined {
+    return this.peekRecord(type, this.recordIdFromKey(type, keyName, keyValue));
+  }
+
+  recordIdFromKey(type: string, keyName: string, keyValue: string): string {
+    let keyMap = this.keyMap as KeyMap;
+    assert(
+      'No `keyMap` has been assigned to the Cache, so `recordIdFromKey` can not work.',
+      !!keyMap
+    );
+    let id = keyMap.keyToId(type, keyName, keyValue);
+    if (!id) {
+      id = this.schema.generateId(type);
+      keyMap.pushRecord({ type, id, keys: { [keyName]: keyValue } });
+    }
+    return id;
+  }
+
+  /**
+   * @deprecated
+   */
   retrieveKey(identity: RecordIdentity, key: string): string | undefined {
+    deprecate(
+      '`Cache#retrieveKey(identity, key)` is deprecated, use `Cache#peekKey(identity, key)`.'
+    );
+    return this.peekKey(identity, key);
+  }
+
+  peekKey(identity: RecordIdentity, key: string): string | undefined {
     const record = this._sourceCache.getRecordSync(identity);
     return record && deepGet(record, ['keys', key]);
   }
 
+  /**
+   * @deprecated
+   */
   retrieveAttribute(identity: RecordIdentity, attribute: string): any {
+    deprecate(
+      '`Cache#retrieveAttribute(identity, attribute)` is deprecated, use `Cache#peekAttribute(identity, key)`.'
+    );
     const record = this._sourceCache.getRecordSync(identity);
     return record && deepGet(record, ['attributes', attribute]);
   }
 
+  peekAttribute(identity: RecordIdentity, attribute: string): any {
+    const record = this._sourceCache.getRecordSync(identity);
+    return record && deepGet(record, ['attributes', attribute]);
+  }
+
+  /**
+   * @deprecated
+   */
   retrieveRelatedRecord(
     identity: RecordIdentity,
     relationship: string
+  ): Model | null | undefined {
+    deprecate(
+      '`Cache#retrieveRelatedRecord(identity, relationship)` is deprecated, use `Cache#peekRelatedRecord(identity, relationship)`.'
+    );
+    return this.peekRelatedRecord(identity, relationship);
+  }
+
+  peekRelatedRecord(
+    identity: RecordIdentity,
+    relationship: string
   ): Model | null | undefined {
     const relatedRecord = this._sourceCache.getRelatedRecordSync(
       identity,
@@ -90,9 +184,22 @@ export default class Cache {
     }
   }
 
+  /**
+   * @deprecated
+   */
   retrieveRelatedRecords(
     identity: RecordIdentity,
     relationship: string
+  ): Model[] | undefined {
+    deprecate(
+      '`Cache#retrieveRelatedRecords(identity, relationship)` is deprecated, use `Cache#peekRelatedRecords(identity, relationship)`.'
+    );
+    return this.peekRelatedRecords(identity, relationship);
+  }
+
+  peekRelatedRecords(
+    identity: RecordIdentity,
+    relationship: string
   ): Model[] | undefined {
     const relatedRecords = this._sourceCache.getRelatedRecordsSync(
       identity,

addon/-private/model.ts

@@ -43,11 +43,11 @@ export default class Model extends EmberObject {
   }
 
   getData(): Record | undefined {
-    return this.store.cache.retrieveRecordData(this.type, this.id);
+    return this.store.cache.peekRecordData(this.type, this.id);
   }
 
   getKey(field: string): string | undefined {
-    return this.store.cache.retrieveKey(this.identity, field);
+    return this.store.cache.peekKey(this.identity, field);
   }
 
   async replaceKey(
@@ -62,7 +62,7 @@ export default class Model extends EmberObject {
   }
 
   getAttribute(field: string): any {
-    return this.store.cache.retrieveAttribute(this.identity, field);
+    return this.store.cache.peekAttribute(this.identity, field);
   }
 
   async replaceAttribute(
@@ -77,7 +77,7 @@ export default class Model extends EmberObject {
   }
 
   getRelatedRecord(relationship: string): Record | null | undefined {
-    return this.store.cache.retrieveRelatedRecord(this.identity, relationship);
+    return this.store.cache.peekRelatedRecord(this.identity, relationship);
   }
 
   async replaceRelatedRecord(
@@ -102,7 +102,7 @@ export default class Model extends EmberObject {
     if (!this._relatedRecords[relationship]) {
       this._relatedRecords[relationship] = HasMany.create({
         getContent: () =>
-          this.store.cache.retrieveRelatedRecords(this.identity, relationship),
+          this.store.cache.peekRelatedRecords(this.identity, relationship),
         addToContent: (record: Model): Promise<void> => {
           return this.addToRelatedRecords(relationship, record);
         },