Merge pull request #337 from orbitjs/update-orbit

Update orbit to v0.17.0-beta.16 and introduce model-aware normalizers and builders

Author: dgeb

addon/-private/cache.ts

@@ -1,4 +1,4 @@
-import { deepGet } from '@orbit/utils';
+import { registerDestructor } from '@ember/destroyable';
 import { Orbit } from '@orbit/core';
 import {
   buildQuery,
@@ -7,29 +7,34 @@ import {
   FullResponse,
   RequestOptions
 } from '@orbit/data';
+import IdentityMap from '@orbit/identity-map';
+import { MemoryCache } from '@orbit/memory';
+import {
+  RecordCacheQueryOptions,
+  RecordCacheTransformOptions
+} from '@orbit/record-cache';
 import {
+  InitializedRecord,
   RecordIdentity,
-  RecordOperation,
-  Record,
   RecordKeyMap,
-  RecordQueryOrExpressions,
-  RecordSchema,
-  RecordTransformBuilder,
+  RecordOperation,
+  RecordOperationResult,
   RecordQuery,
-  RecordTransform,
-  RecordQueryResult,
   RecordQueryExpressionResult,
-  RecordTransformResult,
-  RecordOperationResult,
-  RecordQueryBuilder
+  RecordQueryResult,
+  RecordSchema,
+  RecordTransform,
+  RecordTransformResult
 } from '@orbit/records';
-import { RecordCacheQueryOptions } from '@orbit/record-cache';
-import { MemoryCache } from '@orbit/memory';
-import IdentityMap from '@orbit/identity-map';
-import { registerDestructor } from '@ember/destroyable';
-import Model from './model';
+import { deepGet } from '@orbit/utils';
 import LiveQuery from './live-query';
+import Model from './model';
 import ModelFactory from './model-factory';
+import {
+  ModelAwareQueryBuilder,
+  ModelAwareQueryOrExpressions,
+  ModelAwareTransformBuilder
+} from './utils/model-aware-types';
 import recordIdentitySerializer from './utils/record-identity-serializer';
 
 const { assert } = Orbit;
@@ -40,7 +45,12 @@ export interface CacheSettings {
 }
 
 export default class Cache {
-  private _sourceCache: MemoryCache;
+  private _sourceCache: MemoryCache<
+    RecordCacheQueryOptions,
+    RecordCacheTransformOptions,
+    ModelAwareQueryBuilder,
+    ModelAwareTransformBuilder
+  >;
   private _modelFactory: ModelFactory;
   private _identityMap: IdentityMap<RecordIdentity, Model> = new IdentityMap({
     serializer: recordIdentitySerializer
@@ -69,11 +79,11 @@ export default class Cache {
     return this._sourceCache.schema;
   }
 
-  get queryBuilder(): RecordQueryBuilder {
+  get queryBuilder(): ModelAwareQueryBuilder {
     return this._sourceCache.queryBuilder;
   }
 
-  get transformBuilder(): RecordTransformBuilder {
+  get transformBuilder(): ModelAwareTransformBuilder {
     return this._sourceCache.transformBuilder;
   }
 
@@ -90,18 +100,18 @@ export default class Cache {
   }
 
   get defaultTransformOptions():
-    | DefaultRequestOptions<RequestOptions>
+    | DefaultRequestOptions<RecordCacheTransformOptions>
     | undefined {
     return this._sourceCache.defaultTransformOptions;
   }
 
   set defaultTransformOptions(
-    options: DefaultRequestOptions<RequestOptions> | undefined
+    options: DefaultRequestOptions<RecordCacheTransformOptions> | undefined
   ) {
     this._sourceCache.defaultTransformOptions = options;
   }
 
-  peekRecordData(type: string, id: string): Record | undefined {
+  peekRecordData(type: string, id: string): InitializedRecord | undefined {
     return this._sourceCache.getRecordSync({ type, id });
   }
 
@@ -186,21 +196,21 @@ export default class Cache {
   query<
     RequestData extends RecordQueryResult<Model> = RecordQueryResult<Model>
   >(
-    queryOrExpressions: RecordQueryOrExpressions,
+    queryOrExpressions: ModelAwareQueryOrExpressions,
     options?: DefaultRequestOptions<RecordCacheQueryOptions>,
     id?: string
   ): RequestData;
   query<
     RequestData extends RecordQueryResult<Model> = RecordQueryResult<Model>
   >(
-    queryOrExpressions: RecordQueryOrExpressions,
+    queryOrExpressions: ModelAwareQueryOrExpressions,
     options: FullRequestOptions<RecordCacheQueryOptions>,
     id?: string
   ): FullResponse<RequestData, undefined, RecordOperation>;
   query<
     RequestData extends RecordQueryResult<Model> = RecordQueryResult<Model>
   >(
-    queryOrExpressions: RecordQueryOrExpressions,
+    queryOrExpressions: ModelAwareQueryOrExpressions,
     options?: RecordCacheQueryOptions,
     id?: string
   ): RequestData | FullResponse<RequestData, undefined, RecordOperation> {
@@ -224,7 +234,7 @@ export default class Cache {
   }
 
   liveQuery(
-    queryOrExpressions: RecordQueryOrExpressions,
+    queryOrExpressions: ModelAwareQueryOrExpressions,
     options?: RequestOptions,
     id?: string
   ): LiveQuery {
@@ -269,7 +279,7 @@ export default class Cache {
     }
   }
 
-  lookup(record: Record): Model {
+  lookup(record: InitializedRecord): Model {
     let model = this._identityMap.get(record);
 
     if (!model) {
@@ -282,13 +292,16 @@ export default class Cache {
 
   lookupQueryResult(
     query: RecordQuery,
-    result: RecordQueryResult<Record>
+    result: RecordQueryResult<InitializedRecord>
   ): RecordQueryResult<Model> {
     if (
-      isQueryExpressionResultArray<Record>(result, query.expressions.length)
+      isQueryExpressionResultArray<InitializedRecord>(
+        result,
+        query.expressions.length
+      )
     ) {
-      return (result as RecordQueryExpressionResult<Record>[]).map((i) =>
-        this.lookupQueryExpressionResult(i)
+      return (result as RecordQueryExpressionResult<InitializedRecord>[]).map(
+        (i) => this.lookupQueryExpressionResult(i)
       );
     } else {
       return this.lookupQueryExpressionResult(result);
@@ -297,17 +310,22 @@ export default class Cache {
 
   lookupTransformResult(
     transform: RecordTransform,
-    result: RecordTransformResult<Record>
+    result: RecordTransformResult<InitializedRecord>
   ): RecordTransformResult<Model> {
-    if (isOperationResultArray<Record>(result, transform.operations.length)) {
+    if (
+      isOperationResultArray<InitializedRecord>(
+        result,
+        transform.operations.length
+      )
+    ) {
       return result.map((i) => this.lookupOperationResult(i));
     } else {
       return this.lookupOperationResult(result);
     }
   }
 
   private lookupQueryExpressionResult(
-    result: RecordQueryExpressionResult<Record>
+    result: RecordQueryExpressionResult<InitializedRecord>
   ): RecordQueryExpressionResult<Model> {
     if (Array.isArray(result)) {
       return result.map((i) => (i ? this.lookup(i) : i));
@@ -319,7 +337,7 @@ export default class Cache {
   }
 
   private lookupOperationResult(
-    result: RecordOperationResult<Record>
+    result: RecordOperationResult<InitializedRecord>
   ): RecordOperationResult<Model> {
     if (result) {
       return this.lookup(result);
@@ -341,7 +359,7 @@ export default class Cache {
 
   private generatePatchListener(): (operation: RecordOperation) => void {
     return (operation: RecordOperation) => {
-      const record = operation.record as Record;
+      const record = operation.record as InitializedRecord;
       const { type, id, keys, attributes, relationships } = record;
       const identity = { type, id };
 

addon/-private/factories/memory-source-factory.ts

@@ -1,9 +1,12 @@
 import { MemorySource, MemorySourceSettings } from '@orbit/memory';
+import { ModelAwareNormalizer } from '../utils/model-aware-normalizer';
 
 export default {
   create(injections: MemorySourceSettings): MemorySource {
-    injections.name = injections.name || 'store';
+    const { schema } = injections;
+    injections.name = injections.name ?? 'store';
     injections.cacheSettings = { debounceLiveQueries: false };
+    injections.normalizer = new ModelAwareNormalizer({ schema });
     return new MemorySource(injections);
   }
 };

addon/-private/factories/schema-factory.ts

@@ -25,7 +25,7 @@ export default {
 
       let orbitConfig = app.lookup('ember-orbit:config');
       let modelNames =
-        injections.modelNames ||
+        injections.modelNames ??
         getRegisteredModels(
           app.base.modulePrefix,
           orbitConfig.collections.models

addon/-private/fields/attr.ts

@@ -12,17 +12,27 @@ export interface TrackedAttr {
   set(this: Model, value: unknown): void;
 }
 
-export default function attr(target: Model, key: string): any;
-export default function attr(type?: string, options?: AttributeDefinition): any;
+export default function attr(type: string): any;
+export default function attr(def: AttributeDefinition): any;
 export default function attr(
-  type?: Model | string,
-  options: string | AttributeDefinition = {}
+  typeOrDef?: string | AttributeDefinition,
+  def?: AttributeDefinition
 ): any {
-  function trackedAttr(
-    target: Model,
-    property: string,
-    _: PropertyDescriptor
-  ): TrackedAttr {
+  let attrDef: AttributeDefinition;
+
+  if (typeof typeOrDef === 'string') {
+    attrDef = def ?? {};
+    attrDef.type = typeOrDef;
+  } else {
+    attrDef = typeOrDef ?? {};
+
+    assert(
+      '@attr can be defined with a `type` and `definition` object but not two `definition` objects',
+      def === undefined
+    );
+  }
+
+  return (target: Model, property: string): TrackedAttr => {
     function get(this: Model): unknown {
       assert(
         `The ${this.type} record has been removed from the store, so we cannot lookup the ${property} attr from the cache.`,
@@ -44,16 +54,8 @@ export default function attr(
       }
     }
 
-    defineAttribute(target, property, options as AttributeDefinition);
+    defineAttribute(target, property, attrDef);
 
     return { get, set };
-  }
-
-  if (typeof options === 'string') {
-    options = {};
-    return trackedAttr.apply(null, arguments as any);
-  }
-
-  options.type = type as string;
-  return trackedAttr;
+  };
 }

addon/-private/fields/has-many.ts

@@ -1,5 +1,5 @@
 import { Orbit } from '@orbit/core';
-import { RelationshipDefinition } from '@orbit/records';
+import { HasManyRelationshipDefinition } from '@orbit/records';
 
 import Model from '../model';
 import { getHasManyCache } from '../utils/property-cache';
@@ -11,19 +11,37 @@ export interface TrackedHasMany {
   get(this: Model): Model[];
 }
 
+export default function hasMany(type: string | string[]): any;
+export default function hasMany(
+  def: Partial<HasManyRelationshipDefinition>
+): any;
 export default function hasMany(
   type: string | string[],
-  options: Partial<RelationshipDefinition> = {}
+  def?: Partial<HasManyRelationshipDefinition>
+): any;
+export default function hasMany(
+  typeOrDef: string | string[] | Partial<HasManyRelationshipDefinition>,
+  def?: Partial<HasManyRelationshipDefinition>
 ): any {
-  function trackedHasMany(
-    target: any,
-    property: string,
-    _: PropertyDescriptor
-  ): TrackedHasMany {
-    if (!options.type) {
-      throw new TypeError('@hasMany() require `type` argument.');
-    }
+  let relDef: Partial<HasManyRelationshipDefinition>;
+
+  if (typeof typeOrDef === 'string' || Array.isArray(typeOrDef)) {
+    relDef = def ?? {};
+    relDef.type = typeOrDef;
+  } else {
+    relDef = typeOrDef;
+
+    assert(
+      '@hasMany can be defined with a `type` and `definition` object but not two `definition` objects',
+      def === undefined
+    );
+
+    assert('@hasMany() requires a `type` argument.', relDef.type !== undefined);
+  }
+
+  relDef.kind = 'hasMany';
 
+  return (target: Model, property: string): TrackedHasMany => {
     function get(this: Model): Model[] {
       assert(
         `The ${this.type} record has been removed from the store, so we cannot lookup the ${property} hasMany from the cache.`,
@@ -33,17 +51,12 @@ export default function hasMany(
       return getHasManyCache(this, property).value as Model[];
     }
 
-    defineRelationship(target, property, options);
+    defineRelationship(
+      target,
+      property,
+      relDef as HasManyRelationshipDefinition
+    );
 
     return { get };
-  }
-
-  if (arguments.length === 3) {
-    options = {};
-    return trackedHasMany.apply(null, arguments as any);
-  }
-
-  options.type = type;
-  options.kind = 'hasMany';
-  return trackedHasMany;
+  };
 }