-
-
Notifications
You must be signed in to change notification settings - Fork 1.3k
/
store.js
1547 lines (1205 loc) · 46.2 KB
/
store.js
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/*globals Ember*/
require("ember-data/system/record_arrays");
require("ember-data/system/transaction");
var get = Ember.get, set = Ember.set, fmt = Ember.String.fmt;
// These values are used in the data cache when clientIds are
// needed but the underlying data has not yet been loaded by
// the server.
var UNLOADED = 'unloaded';
var LOADING = 'loading';
var MATERIALIZED = { materialized: true };
var CREATED = { created: true };
// Implementors Note:
//
// The variables in this file are consistently named according to the following
// scheme:
//
// * +id+ means an identifier managed by an external source, provided inside
// the data hash provided by that source.
// * +clientId+ means a transient numerical identifier generated at runtime by
// the data store. It is important primarily because newly created objects may
// not yet have an externally generated id.
// * +type+ means a subclass of DS.Model.
// Used by the store to normalize IDs entering the store. Despite the fact
// that developers may provide IDs as numbers (e.g., `store.find(Person, 1)`),
// it is important that internally we use strings, since IDs may be serialized
// and lose type information. For example, Ember's router may put a record's
// ID into the URL, and if we later try to deserialize that URL and find the
// corresponding record, we will not know if it is a string or a number.
var coerceId = function(id) {
return id+'';
};
var map = Ember.EnumerableUtils.map;
/**
The store contains all of the hashes for records loaded from the server.
It is also responsible for creating instances of DS.Model when you request one
of these data hashes, so that they can be bound to in your Handlebars templates.
Create a new store like this:
MyApp.store = DS.Store.create();
You can retrieve DS.Model instances from the store in several ways. To retrieve
a record for a specific id, use the `find()` method:
var record = MyApp.store.find(MyApp.Contact, 123);
By default, the store will talk to your backend using a standard REST mechanism.
You can customize how the store talks to your backend by specifying a custom adapter:
MyApp.store = DS.Store.create({
adapter: 'MyApp.CustomAdapter'
});
You can learn more about writing a custom adapter by reading the `DS.Adapter`
documentation.
*/
DS.Store = Ember.Object.extend({
/**
Many methods can be invoked without specifying which store should be used.
In those cases, the first store created will be used as the default. If
an application has multiple stores, it should specify which store to use
when performing actions, such as finding records by id.
The init method registers this store as the default if none is specified.
*/
init: function() {
// Enforce API revisioning. See BREAKING_CHANGES.md for more.
var revision = get(this, 'revision');
if (revision !== DS.CURRENT_API_REVISION && !Ember.ENV.TESTING) {
throw new Error("Error: The Ember Data library has had breaking API changes since the last time you updated the library. Please review the list of breaking changes at https://github.com/emberjs/data/blob/master/BREAKING_CHANGES.md, then update your store's `revision` property to " + DS.CURRENT_API_REVISION);
}
if (!get(DS, 'defaultStore') || get(this, 'isDefaultStore')) {
set(DS, 'defaultStore', this);
}
// internal bookkeeping; not observable
this.typeMaps = {};
this.recordCache = [];
this.clientIdToId = {};
this.clientIdToType = {};
this.clientIdToHash = {};
this.recordArraysByClientId = {};
this.relationshipChanges = {};
// Internally, we maintain a map of all unloaded IDs requested by
// a ManyArray. As the adapter loads hashes into the store, the
// store notifies any interested ManyArrays. When the ManyArray's
// total number of loading records drops to zero, it becomes
// `isLoaded` and fires a `didLoad` event.
this.loadingRecordArrays = {};
set(this, 'defaultTransaction', this.transaction());
},
/**
Returns a new transaction scoped to this store. This delegates
responsibility for invoking the adapter's commit mechanism to
a transaction.
Transaction are responsible for tracking changes to records
added to them, and supporting `commit` and `rollback`
functionality. Committing a transaction invokes the store's
adapter, while rolling back a transaction reverses all
changes made to records added to the transaction.
A store has an implicit (default) transaction, which tracks changes
made to records not explicitly added to a transaction.
@see {DS.Transaction}
@returns DS.Transaction
*/
transaction: function() {
return DS.Transaction.create({ store: this });
},
/**
@private
Instructs the store to materialize the data for a given record.
To materialize a record, the store first retrieves the opaque hash that was
passed to either `load()` or `loadMany()`. Then, the hash and the record
are passed to the adapter's `materialize()` method, which allows the adapter
to translate arbitrary hash data structures into the normalized form
the record expects.
The adapter's `materialize()` method will invoke `materializeAttribute()`,
`materializeHasMany()` and `materializeBelongsTo()` on the record to
populate it with normalized values.
@param {DS.Model} record
*/
materializeData: function(record) {
var clientId = get(record, 'clientId'),
cidToHash = this.clientIdToHash,
adapter = get(this, '_adapter'),
hash = cidToHash[clientId];
cidToHash[clientId] = MATERIALIZED;
// Ensures the record's data structures are setup
// before being populated by the adapter.
record.setupData();
if (hash !== CREATED) {
// Instructs the adapter to extract information from the
// opaque hash and materialize the record's attributes and
// relationships.
adapter.materialize(record, hash);
}
},
/**
@private
Returns true if there is already a record for this clientId.
This is used to determine whether cleanup is required, so that
"changes" to unmaterialized records do not trigger mass
materialization.
For example, if a parent record in an association with a large
number of children is deleted, we want to avoid materializing
those children.
@param {String|Number} clientId
@return {Boolean}
*/
recordIsMaterialized: function(clientId) {
return !!this.recordCache[clientId];
},
/**
The adapter to use to communicate to a backend server or other persistence layer.
This can be specified as an instance, a class, or a property path that specifies
where the adapter can be located.
@property {DS.Adapter|String}
*/
adapter: 'DS.Adapter',
/**
@private
Returns a JSON representation of the record using the adapter's
serialization strategy. This method exists primarily to enable
a record, which has access to its store (but not the store's
adapter) to provide a `toJSON()` convenience.
The available options are:
* `includeId`: `true` if the record's ID should be included in
the JSON representation
@param {DS.Model} record the record to serialize
@param {Object} options an options hash
*/
toJSON: function(record, options) {
return get(this, '_adapter').toJSON(record, options);
},
/**
@private
This property returns the adapter, after resolving a possible
property path.
If the supplied `adapter` was a class, or a String property
path resolved to a class, this property will instantiate the
class.
This property is cacheable, so the same instance of a specified
adapter class should be used for the lifetime of the store.
@returns DS.Adapter
*/
_adapter: Ember.computed(function() {
var adapter = get(this, 'adapter');
if (typeof adapter === 'string') {
adapter = get(this, adapter, false) || get(window, adapter);
}
if (DS.Adapter.detect(adapter)) {
adapter = adapter.create();
}
return adapter;
}).property('adapter').cacheable(),
/**
@private
A monotonically increasing number to be used to uniquely identify
data hashes and records.
It starts at 1 so other parts of the code can test for truthiness
when provided a `clientId` instead of having to explicitly test
for undefined.
*/
clientIdCounter: 1,
// .....................
// . CREATE NEW RECORD .
// .....................
/**
Create a new record in the current store. The properties passed
to this method are set on the newly created record.
Note: The third `transaction` property is for internal use only.
If you want to create a record inside of a given transaction,
use `transaction.createRecord()` instead of `store.createRecord()`.
@param {subclass of DS.Model} type
@param {Object} properties a hash of properties to set on the
newly created record.
@returns DS.Model
*/
createRecord: function(type, properties, transaction) {
properties = properties || {};
// Create a new instance of the model `type` and put it
// into the specified `transaction`. If no transaction is
// specified, the default transaction will be used.
var record = type._create({
store: this
});
transaction = transaction || get(this, 'defaultTransaction');
// adoptRecord is an internal API that allows records to move
// into a transaction without assertions designed for app
// code. It is used here to ensure that regardless of new
// restrictions on the use of the public `transaction.add()`
// API, we will always be able to insert new records into
// their transaction.
transaction.adoptRecord(record);
// `id` is a special property that may not be a `DS.attr`
var id = properties.id;
// If the passed properties do not include a primary key,
// give the adapter an opportunity to generate one. Typically,
// client-side ID generators will use something like uuid.js
// to avoid conflicts.
var adapter;
if (Ember.none(id)) {
adapter = get(this, 'adapter');
if (adapter && adapter.generateIdForRecord) {
id = coerceId(adapter.generateIdForRecord(this, record));
properties.id = id;
}
}
id = coerceId(id);
// Create a new `clientId` and associate it with the
// specified (or generated) `id`. Since we don't have
// any data for the server yet (by definition), store
// the sentinel value CREATED as the hash for this
// clientId. If we see this value later, we will skip
// materialization.
var clientId = this.pushHash(CREATED, id, type);
// Now that we have a clientId, attach it to the record we
// just created.
set(record, 'clientId', clientId);
// Move the record out of its initial `empty` state into
// the `loaded` state.
record.loadedData();
// Store the record we just created in the record cache for
// this clientId.
this.recordCache[clientId] = record;
// Set the properties specified on the record.
record.setProperties(properties);
return record;
},
// .................
// . DELETE RECORD .
// .................
/**
For symmetry, a record can be deleted via the store.
@param {DS.Model} record
*/
deleteRecord: function(record) {
record.deleteRecord();
},
// ................
// . FIND RECORDS .
// ................
/**
This is the main entry point into finding records. The first
parameter to this method is always a subclass of `DS.Model`.
You can use the `find` method on a subclass of `DS.Model`
directly if your application only has one store. For
example, instead of `store.find(App.Person, 1)`, you could
say `App.Person.find(1)`.
---
To find a record by ID, pass the `id` as the second parameter:
store.find(App.Person, 1);
App.Person.find(1);
If the record with that `id` had not previously been loaded,
the store will return an empty record immediately and ask
the adapter to find the data by calling the adapter's `find`
method.
The `find` method will always return the same object for a
given type and `id`. To check whether the adapter has populated
a record, you can check its `isLoaded` property.
---
To find all records for a type, call `find` with no additional
parameters:
store.find(App.Person);
App.Person.find();
This will return a `RecordArray` representing all known records
for the given type and kick off a request to the adapter's
`findAll` method to load any additional records for the type.
The `RecordArray` returned by `find()` is live. If any more
records for the type are added at a later time through any
mechanism, it will automatically update to reflect the change.
---
To find a record by a query, call `find` with a hash as the
second parameter:
store.find(App.Person, { page: 1 });
App.Person.find({ page: 1 });
This will return a `RecordArray` immediately, but it will always
be an empty `RecordArray` at first. It will call the adapter's
`findQuery` method, which will populate the `RecordArray` once
the server has returned results.
You can check whether a query results `RecordArray` has loaded
by checking its `isLoaded` property.
*/
find: function(type, id) {
if (id === undefined) {
return this.findAll(type);
}
// We are passed a query instead of an id.
if (Ember.typeOf(id) === 'object') {
return this.findQuery(type, id);
}
return this.findById(type, coerceId(id));
},
/**
@private
This method returns a record for a given type and id
combination.
If the store has never seen this combination of type
and id before, it creates a new `clientId` with the
LOADING sentinel and asks the adapter to load the
data.
If the store has seen the combination, this method
delegates to `findByClientId`.
*/
findById: function(type, id) {
var clientId = this.typeMapFor(type).idToCid[id];
if (clientId) {
return this.findByClientId(type, clientId);
}
clientId = this.pushHash(LOADING, id, type);
// create a new instance of the model type in the
// 'isLoading' state
var record = this.materializeRecord(type, clientId, id);
// let the adapter set the data, possibly async
var adapter = get(this, '_adapter');
if (adapter && adapter.find) { adapter.find(this, type, id); }
else { throw "Adapter is either null or does not implement `find` method"; }
return record;
},
/**
@private
This method returns a record for a given clientId.
If there is no record object yet for the clientId, this method
materializes a new record object. This allows adapters to
eagerly load many raw hashes into the store, and avoid incurring
the cost to create the objects until they are requested.
Several parts of Ember Data call this method:
* findById, if a clientId already exists for a given type and
id combination
* OneToManyChange, which is backed by clientIds, when getChild,
getOldParent or getNewParent are called
* RecordArray, which is backed by clientIds, when an object at
a particular index is looked up
In short, it's a convenient way to get a record for a known
clientId, materializing it if necessary.
@param {Class} type
@param {Number|String} clientId
*/
findByClientId: function(type, clientId) {
var cidToHash, record, id;
record = this.recordCache[clientId];
if (!record) {
// create a new instance of the model type in the
// 'isLoading' state
id = this.clientIdToId[clientId];
record = this.materializeRecord(type, clientId, id);
cidToHash = this.clientIdToHash;
if (typeof cidToHash[clientId] === 'object') {
record.loadedData();
}
}
return record;
},
/**
@private
Given a type and array of `clientId`s, determines which of those
`clientId`s has not yet been loaded.
In preparation for loading, this method also marks any unloaded
`clientId`s as loading.
*/
neededClientIds: function(type, clientIds) {
var neededClientIds = [],
cidToHash = this.clientIdToHash,
clientId;
for (var i=0, l=clientIds.length; i<l; i++) {
clientId = clientIds[i];
if (cidToHash[clientId] === UNLOADED) {
neededClientIds.push(clientId);
cidToHash[clientId] = LOADING;
}
}
return neededClientIds;
},
/**
@private
This method is the entry point that associations use to update
themselves when their underlying data changes.
First, it determines which of its `clientId`s are still unloaded,
then converts the needed `clientId`s to IDs and invokes `findMany`
on the adapter.
*/
fetchUnloadedClientIds: function(type, clientIds) {
var neededClientIds = this.neededClientIds(type, clientIds);
this.fetchMany(type, neededClientIds);
},
/**
@private
This method takes a type and list of `clientId`s, converts the
`clientId`s into IDs, and then invokes the adapter's `findMany`
method.
It is used both by a brand new association (via the `findMany`
method) or when the data underlying an existing association
changes (via the `fetchUnloadedClientIds` method).
*/
fetchMany: function(type, clientIds) {
var clientIdToId = this.clientIdToId;
var neededIds = map(clientIds, function(clientId) {
return clientIdToId[clientId];
});
if (!neededIds.length) { return; }
var adapter = get(this, '_adapter');
if (adapter && adapter.findMany) { adapter.findMany(this, type, neededIds); }
else { throw "Adapter is either null or does not implement `findMany` method"; }
},
/**
@private
`findMany` is the entry point that associations use to generate a
new `ManyArray` for the list of IDs specified by the server for
the association.
Its responsibilities are:
* convert the IDs into clientIds
* determine which of the clientIds still need to be loaded
* create a new ManyArray whose content is *all* of the clientIds
* notify the ManyArray of the number of its elements that are
already loaded
* insert the unloaded clientIds into the `loadingRecordArrays`
bookkeeping structure, which will allow the `ManyArray` to know
when all of its loading elements are loaded from the server.
* ask the adapter to load the unloaded elements, by invoking
findMany with the still-unloaded IDs.
*/
findMany: function(type, ids, record, relationship) {
// 1. Convert ids to client ids
// 2. Determine which of the client ids need to be loaded
// 3. Create a new ManyArray whose content is ALL of the clientIds
// 4. Decrement the ManyArray's counter by the number of loaded clientIds
// 5. Put the ManyArray into our bookkeeping data structure, keyed on
// the needed clientIds
// 6. Ask the adapter to load the records for the unloaded clientIds (but
// convert them back to ids)
if (!Ember.isArray(ids)) {
var adapter = get(this, '_adapter');
if (adapter && adapter.findAssociation) { adapter.findAssociation(this, record, relationship, ids); }
else { throw fmt("Adapter is either null or does not implement `findMany` method", this); }
return this.createManyArray(type, Ember.A());
}
ids = map(ids, function(id) { return coerceId(id); });
var clientIds = this.clientIdsForIds(type, ids);
var neededClientIds = this.neededClientIds(type, clientIds),
manyArray = this.createManyArray(type, Ember.A(clientIds)),
loadingRecordArrays = this.loadingRecordArrays,
clientId, i, l;
// Start the decrementing counter on the ManyArray at the number of
// records we need to load from the adapter
manyArray.loadingRecordsCount(neededClientIds.length);
if (neededClientIds.length) {
for (i=0, l=neededClientIds.length; i<l; i++) {
clientId = neededClientIds[i];
// keep track of the record arrays that a given loading record
// is part of. This way, if the same record is in multiple
// ManyArrays, all of their loading records counters will be
// decremented when the adapter provides the data.
if (loadingRecordArrays[clientId]) {
loadingRecordArrays[clientId].push(manyArray);
} else {
this.loadingRecordArrays[clientId] = [ manyArray ];
}
}
this.fetchMany(type, neededClientIds);
}
return manyArray;
},
/**
@private
This method delegates a query to the adapter. This is the one place where
adapter-level semantics are exposed to the application.
Exposing queries this way seems preferable to creating an abstract query
language for all server-side queries, and then require all adapters to
implement them.
@param {Class} type
@param {Object} query an opaque query to be used by the adapter
@return {DS.AdapterPopulatedRecordArray}
*/
findQuery: function(type, query) {
var array = DS.AdapterPopulatedRecordArray.create({ type: type, query: query, content: Ember.A([]), store: this });
var adapter = get(this, '_adapter');
if (adapter && adapter.findQuery) { adapter.findQuery(this, type, query, array); }
else { throw "Adapter is either null or does not implement `findQuery` method"; }
return array;
},
/**
@private
This method returns an array of all records adapter can find.
It triggers the adapter's `findAll` method to give it an opportunity to populate
the array with records of that type.
@param {Class} type
@return {DS.AdapterPopulatedRecordArray}
*/
findAll: function(type) {
var array = this.all(type);
this.fetchAll(type, array);
return array;
},
/**
@private
*/
fetchAll: function(type, array) {
var sinceToken = this.typeMapFor(type).sinceToken,
adapter = get(this, '_adapter');
set(array, 'isUpdating', true);
if (adapter && adapter.findAll) { adapter.findAll(this, type, sinceToken); }
else { throw "Adapter is either null or does not implement `findAll` method"; }
},
/**
*/
sinceForType: function(type, sinceToken) {
this.typeMapFor(type).sinceToken = sinceToken;
},
/**
*/
didUpdateAll: function(type) {
var findAllCache = this.typeMapFor(type).findAllCache;
set(findAllCache, 'isUpdating', false);
},
/**
This method returns a filtered array that contains all of the known records
for a given type.
Note that because it's just a filter, it will have any locally
created records of the type.
Also note that multiple calls to `all` for a given type will always
return the same RecordArray.
@param {Class} type
@return {DS.RecordArray}
*/
all: function(type) {
var typeMap = this.typeMapFor(type),
findAllCache = typeMap.findAllCache;
if (findAllCache) { return findAllCache; }
var array = DS.RecordArray.create({ type: type, content: Ember.A([]), store: this, isLoaded: true });
this.registerRecordArray(array, type);
typeMap.findAllCache = array;
return array;
},
/**
Takes a type and filter function, and returns a live RecordArray that
remains up to date as new records are loaded into the store or created
locally.
The callback function takes a materialized record, and returns true
if the record should be included in the filter and false if it should
not.
The filter function is called once on all records for the type when
it is created, and then once on each newly loaded or created record.
If any of a record's properties change, or if it changes state, the
filter function will be invoked again to determine whether it should
still be in the array.
Note that the existence of a filter on a type will trigger immediate
materialization of all loaded data for a given type, so you might
not want to use filters for a type if you are loading many records
into the store, many of which are not active at any given time.
In this scenario, you might want to consider filtering the raw
data hashes before loading them into the store.
@param {Class} type
@param {Function} filter
@return {DS.FilteredRecordArray}
*/
filter: function(type, query, filter) {
// allow an optional server query
if (arguments.length === 3) {
this.findQuery(type, query);
} else if (arguments.length === 2) {
filter = query;
}
var array = DS.FilteredRecordArray.create({ type: type, content: Ember.A([]), store: this, filterFunction: filter });
this.registerRecordArray(array, type, filter);
return array;
},
/**
TODO: What is this method trying to do?
*/
recordIsLoaded: function(type, id) {
return !Ember.none(this.typeMapFor(type).idToCid[id]);
},
// ............
// . UPDATING .
// ............
/**
@private
If the adapter updates attributes or acknowledges creation
or deletion, the record will notify the store to update its
membership in any filters.
To avoid thrashing, this method is invoked only once per
run loop per record.
@param {Class} type
@param {Number|String} clientId
@param {DS.Model} record
*/
hashWasUpdated: function(type, clientId, record) {
// Because hash updates are invoked at the end of the run loop,
// it is possible that a record might be deleted after its hash
// has been modified and this method was scheduled to be called.
//
// If that's the case, the record would have already been removed
// from all record arrays; calling updateRecordArrays would just
// add it back. If the record is deleted, just bail. It shouldn't
// give us any more trouble after this.
if (get(record, 'isDeleted')) { return; }
var cidToHash = this.clientIdToHash,
hash = cidToHash[clientId];
if (typeof hash === "object") {
this.updateRecordArrays(type, clientId);
}
},
// ..............
// . PERSISTING .
// ..............
/**
This method delegates committing to the store's implicit
transaction.
Calling this method is essentially a request to persist
any changes to records that were not explicitly added to
a transaction.
*/
commit: function() {
get(this, 'defaultTransaction').commit();
},
/**
Adapters should call this method if they would like to acknowledge
that all changes related to a record have persisted. It can be
called for created, deleted or updated records.
If the adapter supplies a hash, that hash will become the new
canonical data for the record. That will result in blowing away
all local changes and rematerializing the record with the new
data (the "sledgehammer" approach).
Alternatively, if the adapter does not supply a hash, the record
will collapse all local changes into its saved data. Subsequent
rollbacks of the record will roll back to this point.
If an adapter is acknowledging receipt of a newly created record
that did not generate an id in the client, it *must* either
provide a hash or explicitly invoke `store.didReceiveId` with
the server-provided id.
Note that an adapter may not supply a hash when acknowledging
a deleted record.
@param {DS.Model} record the in-flight record
@param {Object} hash an optional hash (see above)
*/
didSaveRecord: function(record, hash) {
if (get(record, 'isNew')) {
this.didCreateRecord(record);
} else if (get(record, 'isDeleted')) {
this.didDeleteRecord(record);
}
if (hash) {
// We're about to clobber the entire data hash with new
// data, so clear out any remaining unacknowledged changes
record.removeInFlightDirtyFactors();
this.updateId(record, hash);
this.updateRecordHash(record, hash);
} else {
this.didUpdateAttributes(record);
this.didUpdateRelationships(record);
}
},
/**
For convenience, if an adapter is performing a bulk commit,
it can also acknowledge all of the records at once.
If the adapter supplies hashes, they must be in the same
order as the array of records passed in as the first
parameter.
@param {#forEach} list a list of records whose changes the
adapter is acknowledging. You can pass any object that
has an ES5-like `forEach` method, including the
`OrderedSet` objects passed into the adapter at commit
time.
@param {Array[Object]} hashes an Array of hashes. This
parameter must be an integer-indexed Array-like.
*/
didSaveRecords: function(list, hashes) {
var i = 0;
list.forEach(function(record) {
this.didSaveRecord(record, hashes && hashes[i++]);
}, this);
},
/**
TODO: Do we need this?
*/
didDeleteRecord: function(record) {
record.adapterDidDelete();
},
/**
This method allows the adapter to acknowledge just that
a record was created, but defer acknowledging specific
attributes or relationships.
This is most useful for adapters that have a multi-step
creation process (first, create the record on the backend,
then make a separate request to add the attributes).
When acknowledging a newly created record using a more
fine-grained approach, you *must* call `didCreateRecord`,
or the record will remain in in-flight limbo forever.
@param {DS.Model} record
*/
didCreateRecord: function(record) {
record.adapterDidCreate();
},
/**
This method allows the adapter to specify that a record
could not be saved because it had backend-supplied validation
errors.
The errors object must have keys that correspond to the
attribute names. Once each of the specified attributes have
changed, the record will automatically move out of the
invalid state and be ready to commit again.
TODO: We should probably automate the process of converting
server names to attribute names using the existing serializer
infrastructure.
@param {DS.Model} record
@param {Object} errors
*/
recordWasInvalid: function(record, errors) {
record.adapterDidInvalidate(errors);
},
/**
This is a lower-level API than `didSaveRecord` that allows an
adapter to acknowledge the persistence of a single attribute.
This is useful if an adapter needs to make multiple asynchronous
calls to fully persist a record. The record will keep track of
which attributes and relationships are still outstanding and
automatically move into the `saved` state once the adapter has
acknowledged everything.
If a value is provided, it clobbers the locally specified value.
Otherwise, the local value becomes the record's last known
saved value (which is used when rolling back a record).
Note that the specified attributeName is the normalized name
specified in the definition of the `DS.Model`, not a key in
the server-provided hash.
Also note that the adapter is responsible for performing any
transformations on the value using the serializer API.
@param {DS.Model} record
@param {String} attributeName
@param {Object} value an
*/
didUpdateAttribute: function(record, attributeName, value) {
record.adapterDidUpdateAttribute(attributeName, value);
},
/**
This method allows an adapter to acknowledge persistence
of all attributes of a record but not relationships or
other factors.
It loops through the record's defined attributes and
notifies the record that they are all acknowledged.
This method does not take optional values, because
the adapter is unlikely to have a hash of normalized
keys and transformed values, and instead of building
one up, it should just call `didUpdateAttribute` as
needed.
This method is intended as a middle-ground between
`didSaveRecord`, which acknowledges all changes to
a record, and `didUpdateAttribute`, which allows an
adapter fine-grained control over updates.
@param {DS.Model} record
*/
didUpdateAttributes: function(record) {
record.eachAttribute(function(attributeName) {
this.didUpdateAttribute(record, attributeName);
}, this);