sproutit-sproutcore 1.0.0.20090416161445 → 1.0.0.20090720093355

data/frameworks/sproutcore/frameworks/datastore/system/record_array.js

@@ -18,7 +18,7 @@
   @since SproutCore 1.0
 */
 
-SC.RecordArray = SC.Object.extend(SC.Enumerable, SC.Array,
+SC.RecordArray = SC.Object.extend(SC.Enumerable, SC.Array, 
   /** @scope SC.RecordArray.prototype */ {
     
   /**
@@ -36,6 +36,35 @@ SC.RecordArray = SC.Object.extend(SC.Enumerable, SC.Array,
     @property {SC.Array}
   */
   storeKeys: null,
+  
+  /**
+    SC.Query object that is set if record array is based on a query.
+    Whenever the store keys content change, the SC.Query will be
+    reapplied so that only matching storeKeys are set on the record
+    array.
+    
+    @property {SC.Query}
+  */
+  queryKey: null,
+  
+  /**
+    The current load state of the RecordArray.  If the storeKeys has a state
+    property, then this property will return that value.  Otherwise it returns
+    SC.Record.READY.
+  */
+  state: function() {
+    var storeKeys = this.get('storeKeys'),
+        ret = (storeKeys && !SC.none(storeKeys.state)) ? storeKeys.get('state') : null;
+    return ret ? ret : SC.Record.READY;
+  }.property().cacheable(),
+  
+  /** @private
+    Cache of records returned from objectAt() so they don't need to
+    be unneccesarily materialized.
+    
+    @property {SC.Query}
+  */
+  _records: null,
 
   // ..........................................................
   // ARRAY PRIMITIVES
@@ -52,6 +81,9 @@ SC.RecordArray = SC.Object.extend(SC.Enumerable, SC.Array,
   /**
     Looks up the store key in the store keys array and materializes a
     records.
+    
+    @param {Number} idx index of the object
+    @return {SC.Record} materialized record
   */
   objectAt: function(idx) {
     var recs      = this._records, 
@@ -65,8 +97,8 @@ SC.RecordArray = SC.Object.extend(SC.Enumerable, SC.Array,
     // not in cache, materialize
     if (!recs) this._records = recs = [] ; // create cache
     storeKey = storeKeys.objectAt(idx);
+    
     if (storeKey) {
-      
       // if record is not loaded already, then ask the data source to 
       // retrieve it
       if (store.readStatus(storeKey) === SC.Record.EMPTY) {
@@ -80,6 +112,11 @@ SC.RecordArray = SC.Object.extend(SC.Enumerable, SC.Array,
   /**
     Pass through to the underlying array.  The passed in objects must be
     records, which can be converted to storeKeys.
+    
+    @param {Number} idx start index
+    @param {Number} amt end index
+    @param {SC.RecordArray} recs to replace with records
+    @return {SC.RecordArray} 'this' after replace
   */
   replace: function(idx, amt, recs) {
     var storeKeys = this.get('storeKeys'), 
@@ -97,6 +134,87 @@ SC.RecordArray = SC.Object.extend(SC.Enumerable, SC.Array,
     return this; 
   },
   
+  /**
+    Called to refresh the query that is attached to this record array.
+    This will force the query to evaluated again against the store. 
+  */
+  refreshQuery: function() {
+    var query = this.get('queryKey');
+    
+    if(query) {
+      var recordType = query.get('recordType');
+      var storeKeys = this.get('store').storeKeysFor(recordType);
+      
+      var recordTypes = SC.Set.create();
+      recordTypes.push(recordType);
+      
+      // clear existing storeKeys, start over by applying all storekeys for 
+      // this recordType
+      this.storeKeys = [];
+      this.applyQuery(storeKeys, recordTypes);
+    }
+    
+  },
+  
+  /**
+    Apply the SC.Query again. This is invoked when new records are loaded
+    or changed in the store (or directly on the array with .replace() ) and 
+    and when we need to refresh all SC.Query 'based' record arrays accordingly.
+    
+    @param {Array} storeKeys to evaluate against the query
+    @param {SC.Set} recordTypes set of record types that changed
+    @param {Boolean} notify to send length notifyPropertyChange()
+  */
+  applyQuery: function(changedStoreKeys, recordTypes, notify) {
+    var newStoreKeys = this.get('storeKeys'), inChangedStoreKeys, 
+      inMatchingStoreKeys, idx, len, storeKey, queryKey = this.get('queryKey'),
+      store = this.get('store');
+      
+    // first check if these changes include any of the record types
+    if(recordTypes && queryKey.recordType && !recordTypes.contains(queryKey.recordType)) return;
+    
+    var matchingStoreKeys = SC.Query.containsStoreKeys(queryKey, 
+      changedStoreKeys, store);
+    
+    // Will iterate through all changed store keys and make sure they:
+    //  1. Are added if they are new AND match the query
+    //  2. Are removed if they exist and do NOT match the query
+    for(idx=0,len=changedStoreKeys.length;idx<len;idx++) {
+      storeKey = changedStoreKeys[idx];
+      inMatchingStoreKeys = (matchingStoreKeys && 
+        matchingStoreKeys.indexOf(storeKey)!==-1) ? YES: NO;
+      var inRecArray = this.storeKeys.indexOf(storeKey)!==-1 ? YES : NO;
+    
+      if(inMatchingStoreKeys && !inRecArray) {
+        newStoreKeys.push(storeKey);
+      }
+      else if(!inMatchingStoreKeys && inRecArray) {
+        newStoreKeys.removeObject(storeKey);
+      }
+      
+    }
+    
+    SC.Query.orderStoreKeys(newStoreKeys, queryKey, store);
+    // clear cache
+    this._records = null;
+    
+    this.storeKeys = newStoreKeys.addObserver('[]', this, this._storeKeysContentDidChange);
+    if(notify) this.notifyPropertyChange('length');
+  },
+  
+  /**
+    Will call findAll() on the store, which allows for chaining findAll
+    statements. Note that chaining findAll() will not notify the data
+    source (only the initial findAll will).
+    
+    @param {SC.Query} queryKey a SC.Query object
+    @returns {SC.RecordArray} 
+  */
+  
+  findAll: function(queryKey) {
+    return this.get('store').findAll(queryKey, null, this);
+  },
+  
   // ..........................................................
   // INTERNAL SUPPORT
   // 
@@ -105,19 +223,25 @@ SC.RecordArray = SC.Object.extend(SC.Enumerable, SC.Array,
     Invoked whenever the storeKeys array changes.  Observes changes.
   */
   _storeKeysDidChange: function() {
+    
     var storeKeys = this.get('storeKeys');
-    var prev = this._prevStoreKeys, f = this._storeKeysContentDidChange;
-
+    
+    var prev = this._prevStoreKeys, 
+        f    = this._storeKeysContentDidChange,
+        fs   = this._storeKeysStateDidChange;
+    
     if (storeKeys === prev) return this; // nothing to do
     
     if (prev) {
       prev.removeObserver('[]', this, f);
+      prev.removeObserver('state', this, fs);
     }
 
     this._prevStoreKeys = storeKeys;
-
+    
     if (storeKeys) {
       storeKeys.addObserver('[]', this, f);
+      storeKeys.addObserver('state', this, fs);
     }
     
     var rev = (storeKeys) ? storeKeys.propertyRevision : -1 ;
@@ -125,6 +249,13 @@ SC.RecordArray = SC.Object.extend(SC.Enumerable, SC.Array,
     
   }.observes('storeKeys'),
   
+  /** @private
+    Invoked whenever the state property of the storeKeys change.
+  */
+  _storeKeysStateDidChange: function() {
+    this.notifyPropertyChange('state');
+  },
+  
   /** @private
     Invoked whenever the content of the storeKeys array changes.  This will
     dump any cached record lookup and then notify that the enumerable content
@@ -132,6 +263,13 @@ SC.RecordArray = SC.Object.extend(SC.Enumerable, SC.Array,
   */
   _storeKeysContentDidChange: function(target, key, value, rev) {
     this._records = null ; // clear cache
+    // if this record array is based on a queryKey reapply the
+    // the query before setting the storeKeys to ensure it always conforms
+    
+    if(SC.instanceOf(this.queryKey, SC.Query)) {
+      this.storeKeys = SC.Query.containsStoreKeys(this.queryKey, value, this.store);
+      this.notifyPropertyChange('length');
+    }
     
     this.beginPropertyChanges()
       .notifyPropertyChange('length')

data/frameworks/sproutcore/frameworks/datastore/system/store.js

@@ -48,6 +48,11 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
   */
   isNested: NO,
   
+  /**
+    This type of store is not nested.
+  */
+  commitRecordsAutomatically: NO,
+  
   // ..........................................................
   // DATA SOURCE SUPPORT
   // 
@@ -56,6 +61,11 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     Convenience method.  Sets the current data source to the passed property.
     This will also set the store property on the dataSource to the receiver.
     
+    If you are using this from the core.js method of your app, you may need to
+    just pass a string naming your data source class.  If this is the case,
+    then your data source will be instantiated the first time it is requested.
+    
+    @param {SC.DataSource|String} dataSource the data source
     @returns {SC.Store} receiver
   */
   from: function(dataSource) {
@@ -63,6 +73,17 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     return this ;
   },
   
+  // lazily convert data source to real object
+  _getDataSource: function() {
+    var ret = this.get('dataSource');
+    if (typeof ret === SC.T_STRING) {
+      ret = SC.objectForPropertyPath(ret);
+      if (ret) ret = ret.create();
+      if (ret) this.set('dataSource', ret);
+    }
+    return ret;
+  },
+  
   /**
     Convenience method.  Creates a CascadeDataSource with the passed 
     data source arguments and sets the CascadeDataSource as the data source 
@@ -95,12 +116,17 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
       store.commitChanges().destroy();
     }}}
     
+    @param {Hash} attrs optional attributes to set on new store
     @returns {SC.NestedStore} new nested store chained to receiver
   */
-  chain: function() {
-    var ret = SC.NestedStore.create({ parentStore: this }) ; 
-    var nested = this.nestedStores;
-    if (!nested) nested =this.nestedStores = [];
+  chain: function(attrs) {
+    if (!attrs) attrs = {};
+    attrs.parentStore = this;
+    
+    var ret    = SC.NestedStore.create(attrs),
+        nested = this.nestedStores;
+        
+    if (!nested) nested = this.nestedStores = [];
     nested.push(ret);
     return ret ;
   },
@@ -119,6 +145,18 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     return this ;
   },
 
+  /**
+    Used to determine if a nested store belongs directly or indirectly to the
+    receiver.
+    
+    @param {SC.Store} store store instance
+    @returns {Boolean} YES if belongs
+  */
+  hasNestedStore: function(store) {
+    while(store && (store !== this)) store = store.get('parentStore');
+    return store === this ;
+  },
+
   // ..........................................................
   // SHARED DATA STRUCTURES 
   // 
@@ -159,6 +197,20 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
   */
   revisions: null,
 
+  /** @private
+    Stores three sets of record property changes (storeKeys, statuses
+    and recordTypes) which is used when _notifyRecordPropertyChange is 
+    called. Makes it possible to only execute once at the end of 
+    the runloop.
+  
+    @property {Hash}
+  */
+  recordPropertyChanges: { 
+    storeKeys: [],
+    records: [],
+    statusOnly: []
+  },
+
   /**
     Array indicates whether a data hash is possibly in use by an external 
     record for editing.  If a data hash is editable then it may be modified
@@ -181,6 +233,15 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
   */
   changelog: null,
   
+  /**
+    A set of SC.RecordArray that have been returned from findAll with an 
+    SC.Query. These will all be notified with _notifyRecordArraysWithQuery() 
+    whenever the store changes.
+  
+    @property {Array}
+  */
+  recordArraysWithQuery: null,
+  
   // ..........................................................
   // CORE ATTRIBUTE API
   // 
@@ -316,6 +377,10 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
   
   /**
     Writes the current status for a storeKey.
+    
+    @param {Number} storeKey the store key
+    @param {String} newStatus the new status
+    @returns {SC.Store} receiver
   */
   writeStatus: function(storeKey, newStatus) {
     // use writeDataHash for now to handle optimistic lock.  maximize code 
@@ -350,41 +415,122 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
       storeKey = storeKeys;
     }
     
+    SC.RunLoop.begin();
     for(idx=0;idx<len;idx++) {
       if (isArray) storeKey = storeKeys[idx];
       this.revisions[storeKey] = rev;
       this._notifyRecordPropertyChange(storeKey, statusOnly);
     }
     
+    SC.RunLoop.end();
+    
     return this ;
   },
 
-  /**
-    Will notify any record instances of the property change at the end of 
-    the run loop.  Also notifies any inherited record instances as well.
+  /** @private 
+    Will push all changes to a the recordPropertyChanges property
+    and execute flushRecordChanges() once at the end of the runloop.
   */
   _notifyRecordPropertyChange: function(storeKey, statusOnly) {
-
-    var records = this.records, rec ;
     
-    // schedule
-    if (records && (rec=records[storeKey])) {
-      rec.storeDidChangeProperties(statusOnly);
-    }
-
+    var records = this.records, rec, editState;
+    
     // pass along to nested stores
-    var nestedStores = this.get('nestedStores'), len, idx, store;
+    var nestedStores = this.get('nestedStores'), len, idx, store, status;
     var K = SC.Store;
     len = nestedStores ? nestedStores.length : 0 ;
     for(idx=0;idx<len;idx++) {
       store = nestedStores[idx];
-      if (store.storeKeyEditState(storeKey) === K.INHERITED) {
+      status = store.readStatus(storeKey);
+      editState = store.storeKeyEditState(storeKey);
+      
+      // when store needs to propagate out changes in the parent store
+      // to nested stores
+      if(editState!==K.INHERITED && (status & SC.Record.BUSY)) {
+        // make sure nested store does not have any changes before resetting
+        if(store.get('hasChanges')) throw K.CHAIN_CONFLICT_ERROR;
+        store.reset();
+      }
+      
+      if(store.storeKeyEditState(storeKey) === K.INHERITED) {
         store._notifyRecordPropertyChange(storeKey, statusOnly);
       }
     }
+    
+    // schedule
+    this.recordPropertyChanges.storeKeys.push(storeKey);
+    
+    if (records && (rec=records[storeKey])) {
+      this.recordPropertyChanges.records.push(storeKey);
+      if(statusOnly) {
+        this.recordPropertyChanges.statusOnly.push(storeKey);
+      }
+    }
+    
+    this._flushRecordChanges();
+    
     return this;
   },
   
+  /** @private 
+    Will notify any record instances of the property change at the end of 
+    the run loop.  Also notifies any inherited record instances as well.
+    
+    Will also notify any record arrays with queries to refresh based on
+    the new/changed store keys.
+  */
+  
+  _flushRecordChanges: function() {
+    var storeKeys = this.recordPropertyChanges.storeKeys, 
+      statusOnly = this.recordPropertyChanges.statusOnly,
+      records = this.recordPropertyChanges.records, rec, 
+      recordType, recordTypes = SC.Set.create(), status, idx, len, storeKey;
+    
+    for(idx=0,len=storeKeys.length;idx<len;idx++) {
+      storeKey = storeKeys[idx];
+      
+      if(records.indexOf(storeKey)!==-1) {
+        status = statusOnly.indexOf(storeKey)!==-1 ? YES: NO;
+        rec = this.records[storeKey];
+        rec.storeDidChangeProperties(status);
+        // remove it so we don't trigger this twice
+        records.removeObject(storeKey);
+      }
+      
+      recordType = SC.Store.recordTypeFor(storeKey);
+      if(!recordTypes.contains(recordType)) {
+        recordTypes.push(recordType);
+      }
+    
+    }
+    
+    this._notifyRecordArraysWithQuery(storeKeys, recordTypes);
+    
+    // reset for next run loop
+    this.recordPropertyChanges.storeKeys = [];
+    this.recordPropertyChanges.records = [];
+    this.recordPropertyChanges.statusOnly = [];
+  },
+  
+  /** @private 
+    Will ask all record arrays that have been returned from findAll
+    with an SC.Query to reapply their query with the new storeKeys
+    
+    @param {SC.IndexSet} storeKeys set of storeKeys that changed
+    @param {SC.Set} recordTypes
+  */
+  
+  _notifyRecordArraysWithQuery: function(storeKeys, recordTypes) {
+    var recordArrays = this.recordArraysWithQuery;
+    if(!recordArrays) return;
+    
+    for(var idx=0, len=recordArrays.length;idx<len;idx++) {
+      var recArray = recordArrays[idx];
+      // if this record array still exists, reapply the query
+      if(recArray) recArray.applyQuery(storeKeys, recordTypes, YES);
+    }
+  },
+  
   /**
     Resets the store content.  This will clear all internal data for all
     records, resetting them to an EMPTY state.  You generally do not want
@@ -405,13 +551,15 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
 
     var records = this.records, storeKey;
     if (records) {
+      SC.RunLoop.begin();
       for(storeKey in records) {
         if (!records.hasOwnProperty(storeKey)) continue ;
         this._notifyRecordPropertyChange(storeKey, NO);
       }
+      SC.RunLoop.end();
     }
     
-    this.set('hasChanges', NO);    
+    this.set('hasChanges', NO);
   },
   
   /** @private
@@ -430,49 +578,49 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @param {Boolean} force
     @returns {SC.Store} receiver
   */
-  commitChangesFromNestedStore: function(nestedStore, changes, force)
-  {
+  commitChangesFromNestedStore: function(nestedStore, changes, force) {
     // first, check for optimistic locking problems
     if (!force) this._verifyLockRevisions(changes, nestedStore.locks);
     
     // OK, no locking issues.  So let's just copy them changes. 
     // get local reference to values.
-    var len = changes.length, i, storeKey ;
-    var my_dataHashes, my_statuses, my_editables, my_revisions;
-    var ch_dataHashes, ch_statuses, ch_revisions;
+    var len = changes.length, i, storeKey, myDataHashes, myStatuses, 
+      myEditables, myRevisions, chDataHashes, chStatuses, chRevisions;
+    
+    myRevisions  = this.revisions ;
+    myDataHashes = this.dataHashes;
+    myStatuses   = this.statuses;
+    myEditables  = this.editables ;
     
-    my_revisions  = this.revisions ;
-    my_dataHashes = this.dataHashes;
-    my_statuses   = this.statuses;
-    my_editables  = this.editables ;
-
     // setup some arrays if needed
-    if (!my_editables) my_editables = this.editables = [] ;
+    if (!myEditables) myEditables = this.editables = [] ;
     
-    ch_dataHashes = nestedStore.dataHashes;
-    ch_revisions  = nestedStore.revisions ;
-    ch_statuses   = nestedStore.statuses;
+    chDataHashes = nestedStore.dataHashes;
+    chRevisions  = nestedStore.revisions ;
+    chStatuses   = nestedStore.statuses;
 
+    SC.RunLoop.begin();
     for(i=0;i<len;i++) {
       storeKey = changes[i];
 
       // now copy changes
-      my_dataHashes[storeKey] = ch_dataHashes[storeKey];
-      my_statuses[storeKey]   = ch_statuses[storeKey];
-      my_revisions[storeKey]  = ch_revisions[storeKey];
+      myDataHashes[storeKey] = chDataHashes[storeKey];
+      myStatuses[storeKey]   = chStatuses[storeKey];
+      myRevisions[storeKey]  = chRevisions[storeKey];
       
-      my_editables[storeKey] = 0 ; // always make dataHash no longer editable
+      myEditables[storeKey] = 0 ; // always make dataHash no longer editable
       
       this._notifyRecordPropertyChange(storeKey, NO);
     }
-
+    SC.RunLoop.end();
+    
     // add any records to the changelog for commit handling
-    var my_changelog = this.changelog, ch_changelog = nestedStore.changelog;
-    if (ch_changelog) {
-      if (!my_changelog) my_changelog = this.changelog = SC.Set.create();
-      my_changelog.addEach(ch_changelog);
+    var myChangelog = this.changelog, chChangelog = nestedStore.changelog;
+    if (chChangelog) {
+      if (!myChangelog) myChangelog = this.changelog = SC.Set.create();
+      myChangelog.addEach(chChangelog);
     }  
-    this.changelog=my_changelog;
+    this.changelog = myChangelog;
     
     return this ;
   },
@@ -507,7 +655,6 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
   // HIGH-LEVEL RECORD API
   // 
   
-  
   /**
     Finds a record instance with the specified recordType and id, returning 
     the record instance.  If no matching record could be found, asks the 
@@ -515,21 +662,40 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     the record, returns null.
     
     Note that if you try to find a record id that does not exist in memory,
-    a dataSource may load it from ths server.  In this case, this method will
+    a dataSource may load it from the server.  In this case, this method will
     return a record instance with a status of SC.Record.BUSY_LOADING to indicate
     that it is still fetching the data from the server.
     
-    @param {SC.Record} recordType the expected record type
+    You can also pass YES to the isRefresh parameter which will make sure to
+    always go back to the data source so that you can go back to refresh the 
+    record that is currently in the store. In that case, the record will
+    get the SC.Record.BUSY_REFRESH status until server has responded and
+    store is refreshed.
+    
+    @param {SC.Record|String} recordType the expected record type
     @param {String} id the id to load
+    @param {Boolean} isRefresh
     @returns {SC.Record} record instance or null
   */
-  find: function(recordType, id) {
+  find: function(recordType, id, isRefresh) {
+    // if recordType is passed as string, find object
+    if(SC.typeOf(recordType)===SC.T_STRING) {
+      recordType = SC.objectForPropertyPath(recordType);
+    }
+    
     // first attempt to find the record in the local store
     var storeKey = recordType.storeKeyFor(id);
+    
     if (this.readStatus(storeKey) === SC.Record.EMPTY) {
       storeKey = this.retrieveRecord(recordType, id);
     }
     
+    // also make sure to reach to the data source to actually
+    // retrieveRecord if isRefresh is YES, even if it already exists in store
+    if(isRefresh) {
+      this.retrieveRecord(recordType, id, null, isRefresh);
+    }
+    
     // now we have the storeKey, materialize the record and return it.
     return storeKey ? this.materializeRecord(storeKey) : null ;
   },
@@ -545,43 +711,94 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     
     h2. Query Keys
     
-    The kind of query key you pass is generally determined by the type of 
-    persistent stores you hook up for your application.  Most stores, however,
-    will accept an SC.Record subclass as the query key.  This will return 
+    The kind of fetchKey you pass is generally determined by the type of 
+    persistent stores you hook up for your application. Most stores, however,
+    will accept an SC.Record subclass as the fetchKey. It is up to your data source
+    to figure out which storeKeys to return based on the fetchKey. This will return 
     a RecordArray matching all instances of that class as is relevant to your
-    application.  
+    application, for instance: findAll(MyApp.MyModel)
+    
+    You can also pass an SC.Query object as your fetchKey, for instance:
+    var q = SC.Query.create({ recordType: MyApp.MyModel, 
+      conditions: "firstName = 'John'", orderBy: "lastName ASC"});
+    var records = MyApp.store.findAll(q);
+    
+    If an SC.Query is given as fetchKey, the record array created in
+    findAll() will automatically update when records are added, changed, 
+    or removed from the store. When a fetchKey is given, you do not have to 
+    return anything from the data source as you are from then on delegating
+    the responsibility to keep the record array updated to the store.
     
     Once you retrieve a RecordArray, you can filter the results even further
     by using the filter() method, which may issue even more specific requests.
     
-    @param {Object} queryKey key describing the type of records to fetch
-    @param {Hash} params optional additional parameters to pass along
-    @param {SC.Store} _store this is a private param.  Do not pass
+    @param {Object|SC.Query} fetchKey key describing the type of records to 
+      fetch or a predefined SC.Query object
+    @param {Hash} params optional additional parameters to pass along to the
+      data source
+    @param {SC.RecordArray} recordArray optional if you want to find just 
+      within a given record array
     @returns {SC.RecordArray} matching set or null if no server handled it
   */
-  findAll: function(queryKey, params, _store) { 
-    if (!_store) _store = this;
-
-    var source = this.get('dataSource'), ret, storeKeys, cacheKey ;
-    if (source) {
-      
-      // ask the dataSource to provide a storeKey array
-      storeKeys = source.fetchRecords.call(source, this, queryKey, params);
-      if (storeKeys) {
-        
-        // if an array was provided, see if a wrapper already exists for 
-        // this store.  Otherwise create it
-        cacheKey = SC.keyFor('__records__', SC.guidFor(storeKeys));
-        ret = this[cacheKey];
-        if (!ret) {
-          ret = SC.RecordArray.create({store: _store, storeKeys: storeKeys});
-          this[cacheKey] = ret ; // save for future reuse.
-        }
+  findAll: function(fetchKey, params, recordArray) { 
+    var _store = this, source = this._getDataSource(), ret = [], storeKeys, 
+      sourceRet, cacheKey;
+    
+    if(recordArray) {
+      // giving a recordArray will circumvent the data source
+      // typically happens when chaining findAll statements
+      storeKeys = SC.Query.containsRecords(fetchKey, recordArray, _store);
+    }
+    else if (source) {
+      // call fetch() on the data source.
+      sourceRet = source.fetch.call(source, this, fetchKey, params);
+      if(SC.typeOf(sourceRet)===SC.T_ARRAY) {
+        storeKeys = sourceRet;
       }
     }
+    
+    // if SC.Query returned from data source or no data source was given 
+    if(!storeKeys && SC.instanceOf(fetchKey, SC.Query)) {
+      storeKeys = SC.Query.containsStoreKeys(fetchKey, null, _store);
+    }
+    
+    ret = this.recordArrayFromStoreKeys(storeKeys, fetchKey, _store);
     return ret ;
   },
-
+  
+  /**
+    Creates a record array based on passed storeKeys. Will return
+    cache if records are already cached, if not store them for reuse.
+    
+    @param {Array} storeKeys added to returned record array
+    @param {Object|SC.Query} fetchKey
+    @param {SC.Store} _store
+    @returns {SC.RecordArray} matching set or null if no server handled it
+  */
+  
+  recordArrayFromStoreKeys: function(storeKeys, fetchKey, _store) {
+    var ret, isQuery = SC.instanceOf(fetchKey, SC.Query), cacheKey, queryKey;
+    
+    // if an array was provided, see if a wrapper already exists for 
+    // this store.  Otherwise create it
+    cacheKey = SC.keyFor('__records__', [SC.guidFor(storeKeys), SC.guidFor(fetchKey)].join('_'));
+    ret = this[cacheKey];
+    if (!ret) {
+      if(isQuery) queryKey = fetchKey;
+      ret = SC.RecordArray.create({store: _store, storeKeys: storeKeys, queryKey: queryKey});
+      
+      // store reference to record array if SC.Query so we can notify it
+      // when store changes
+      if(isQuery) {
+        if (!this.recordArraysWithQuery) this.recordArraysWithQuery = [];
+        this.recordArraysWithQuery.push(ret);
+      }
+      
+      this[cacheKey] = ret ; // save for future reuse.
+    }
+    return ret;
+  },
+  
   /**
     Array of all records currently in the store with the specified
     type.  This method only reflects the actual records loaded into memory and
@@ -592,16 +809,15 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @returns {SC.Array} array instance - usually SC.RecordArray
   */
   recordsFor: function(recordType) {
-    var storeKeys = [], storeKeysById = recordType.prototype.storeKeysById; 
-    var id, storeKey, ret;
+    var storeKeys     = [], 
+        storeKeysById = recordType.storeKeysById(),
+        id, storeKey, ret;
     
     // collect all non-empty store keys
-    if (storeKeysById) {
-      for(id in storeKeysById) {
-        storeKey = storeKeysById[id]; // get the storeKey
-        if (this.readStatus(storeKey) !== SC.RECORD_EMPTY) {
-          storeKeys.push(storeKey);
-        }
+    for(id in storeKeysById) {
+      storeKey = storeKeysById[id]; // get the storeKey
+      if (this.readStatus(storeKey) !== SC.RECORD_EMPTY) {
+        storeKeys.push(storeKey);
       }
     }
     
@@ -667,18 +883,24 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @returns {SC.Record} Returns the created record
   */
   createRecord: function(recordType, dataHash, id) {
-
-    var primaryKey, storeKey, status, K = SC.Record, changelog;
+    
+    var primaryKey, storeKey, status, K = SC.Record, changelog, defaultVal;
     
     // First, try to get an id.  If no id is passed, look it up in the 
     // dataHash.
     if (!id && (primaryKey = recordType.prototype.primaryKey)) {
       id = dataHash[primaryKey];
+      // if still no id, check if there is a defaultValue function for
+      // the primaryKey attribute and assign that
+      defaultVal = recordType.prototype[primaryKey] ? recordType.prototype[primaryKey].defaultValue : null;
+      if(!id && SC.typeOf(defaultVal)===SC.T_FUNCTION) {
+        id = dataHash[primaryKey] = defaultVal();
+      }
     }
     
     // Next get the storeKey - base on id if available
     storeKey = id ? recordType.storeKeyFor(id) : SC.Store.generateStoreKey();
-
+    
     // now, check the state and do the right thing.
     status = this.readStatus(storeKey);
     
@@ -695,15 +917,21 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     }
     
     // add dataHash and setup initial status -- also save recordType
-    this.writeDataHash(storeKey, dataHash, K.READY_NEW);
+    this.writeDataHash(storeKey, (dataHash ? dataHash : {}), K.READY_NEW);
+    
     SC.Store.replaceRecordTypeFor(storeKey, recordType);
     this.dataHashDidChange(storeKey);
-
+    
     // Record is now in a committable state -- add storeKey to changelog
     changelog = this.changelog;
     if (!changelog) changelog = SC.Set.create();
     changelog.add(storeKey);
-    this.changelog=changelog;
+    this.changelog = changelog;
+    
+    // if commit records is enabled
+    if(this.get('commitRecordsAutomatically')){
+      this.invokeLast(this.commitRecords);
+    }
     
     // finally return materialized record
     return this.materializeRecord(storeKey) ;
@@ -769,15 +997,21 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     } else status = K.DESTROYED_DIRTY ;
     
     // remove the data hash, set new status
-    this.removeDataHash(storeKey, status);
+    this.writeStatus(storeKey, status);
     this.dataHashDidChange(storeKey);
 
     // add/remove change log
     changelog = this.changelog;
     if (!changelog) changelog = this.changelog = SC.Set.create();
+
     ((status & K.DIRTY) ? changelog.add(storeKey) : changelog.remove(storeKey));
     this.changelog=changelog;
-    
+
+    // if commit records is enabled
+    if(this.get('commitRecordsAutomatically')){
+      this.invokeLast(this.commitRecords);
+    }
+        
     return this ;
   },
   
@@ -854,13 +1088,17 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     
     // record data hash change
     this.dataHashDidChange(storeKey, null);
-    
     // record in changelog
     changelog = this.changelog ;
     if (!changelog) changelog = this.changelog = SC.Set.create() ;
     changelog.add(storeKey);
     this.changelog=changelog;
     
+    // if commit records is enabled
+    if(this.get('commitRecordsAutomatically')){
+      this.invokeLast(this.commitRecords);
+    }
+    
     return this ;
   },
 
@@ -918,22 +1156,23 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     instance itself using materializeRecord()
     
     @param {SC.Record|Array} recordTypes class or array of classes
-    @param {Array} ids ids to destroy
-    @param {Array} storeKeys (optional) store keys to destroy
+    @param {Array} ids ids to retrieve
+    @param {Array} storeKeys (optional) store keys to retrieve
+    @param {Boolean} isRefresh
     @returns {Array} storeKeys to be retrieved
   */
-  retrieveRecords: function(recordTypes, ids, storeKeys, _isRefresh) {
-
-    var source  = this.get('dataSource'),
+  retrieveRecords: function(recordTypes, ids, storeKeys, isRefresh) {
+    
+    var source  = this._getDataSource(),
         isArray = SC.typeOf(recordTypes) === SC.T_ARRAY,
-        len     = (storeKeys === undefined) ? ids.length : storeKeys.length,
+        len     = (!storeKeys) ? ids.length : storeKeys.length,
         ret     = [],
         rev     = SC.Store.generateStoreKey(),
         K       = SC.Record,
         recordType, idx, storeKey, status;
         
     if (!isArray) recordType = recordTypes;
-
+    
     // if no storeKeys were passed, map recordTypes + ids
     for(idx=0;idx<len;idx++) {
       
@@ -950,14 +1189,12 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
       
       // K.EMPTY, K.ERROR, K.DESTROYED_CLEAN - initial retrieval
       if ((status == K.EMPTY) || (status == K.ERROR) || (status == K.DESTROYED_CLEAN)) {
-
         this.writeStatus(storeKey, K.BUSY_LOADING);
         this.dataHashDidChange(storeKey, rev, YES);
         ret.push(storeKey);
 
       // otherwise, ignore record unless isRefresh is YES.
-      } else if (_isRefresh) {
-        
+      } else if (isRefresh) {
         // K.READY_CLEAN, K.READY_DIRTY, ignore K.READY_NEW
         if (status & K.READY) {
           this.writeStatus(storeKey, K.BUSY_REFRESH | (status & 0x03)) ;
@@ -977,14 +1214,14 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
       }
     }
     
-    // now commit storekeys to dataSource
+    // now retrieve storekeys from dataSource
     if (source) {
-      var ok = source.retrieveRecords.call(source, this, ret);
+      var ok = source.retrieveRecords.call(source, this, ret, ids);
       if (ok === NO) ret.length = 0; // could not find.
     }
     return ret ;
   },
-
+  
   _TMP_RETRIEVE_ARRAY: [],
   
   /**
@@ -1001,13 +1238,14 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @param {SC.Record} recordType class
     @param {String} id id to retrieve
     @param {Number} storeKey (optional) store key
+    @param {Boolean} isRefresh
     @returns {Number} storeKey that was retrieved 
   */
-  retrieveRecord: function(recordType, id, storeKey, _isRefresh) {
+  retrieveRecord: function(recordType, id, storeKey, isRefresh) {
     var array = this._TMP_RETRIEVE_ARRAY,
         ret;
-        
-    if (storeKey !== undefined) {
+    
+    if (storeKey) {
       array[0] = storeKey;
       storeKey = array;
       id = null ;
@@ -1016,7 +1254,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
       id = array;
     }
     
-    ret = this.retrieveRecords(recordType, id, storeKey, _isRefresh);
+    ret = this.retrieveRecords(recordType, id, storeKey, isRefresh);
     array.length = 0 ;
     return ret[0];
   },
@@ -1060,7 +1298,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @returns {SC.Bool} if the action was succesful.
   */
   commitRecords: function(recordTypes, ids, storeKeys) {
-    var source    = this.get('dataSource'),
+    var source    = this._getDataSource(),
         isArray   = SC.typeOf(recordTypes) === SC.T_ARRAY,    
         retCreate= [], retUpdate= [], retDestroy = [], 
         rev       = SC.Store.generateStoreKey(),
@@ -1073,6 +1311,10 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     if(recordTypes===undefined && ids===undefined && storeKeys===undefined){
       storeKeys=this.changelog;
     }
+    
+    // if no storeKeys or ids at this point, return
+    if(!storeKeys && !ids) return;
+    
     len = (storeKeys === undefined) ? ids.length : storeKeys.length;
     
     for(idx=0;idx<len;idx++) {
@@ -1089,7 +1331,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
       // collect status and process
       status = this.readStatus(storeKey);
       
-      if ((status == K.EMPTY) || (status == K.ERROR) || (status == K.DESTROYED_CLEAN)) {
+      if ((status == K.EMPTY) || (status == K.ERROR)) {
         throw K.NOT_FOUND_ERROR ;
       }else{
         if(status==K.READY_NEW){
@@ -1104,6 +1346,9 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
           this.writeStatus(storeKey, K.BUSY_DESTROYING);
           this.dataHashDidChange(storeKey, rev, YES);
           retDestroy.push(storeKey);
+        } else if (status==K.DESTROYED_CLEAN) {
+          this.dataHashDidChange(storeKey, rev, YES);
+          retDestroy.push(storeKey);
         }
         // ignore K.READY_CLEAN, K.BUSY_LOADING, K.BUSY_CREATING, K.BUSY_COMMITTING, 
         // K.BUSY_REFRESH_CLEAN, K_BUSY_REFRESH_DIRTY, KBUSY_DESTROYING
@@ -1160,7 +1405,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @returns {SC.Store} the store.
   */
   cancelRecords: function(recordTypes, ids, storeKeys) {
-    var source  = this.get('dataSource'),
+    var source  = this._getDataSource(),
         isArray = SC.typeOf(recordTypes) === SC.T_ARRAY,
         K       = SC.Record,
         ret     = [],
@@ -1260,12 +1505,11 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
       if (isArray) {
         recordType = recordTypes.objectAt(idx) || SC.Record;
         primaryKey = recordType.prototype.primaryKey ;
-      } 
+      }
       id = (ids) ? ids.objectAt(idx) : dataHash[primaryKey];
       ret[idx] = storeKey = recordType.storeKeyFor(id); // needed to cache
       this.pushRetrieve(recordType, id, dataHash, storeKey);
     }
-    
     // return storeKeys
     return ret ;
   },
@@ -1337,24 +1581,25 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @returns {SC.Store} reciever
   */
   dataSourceDidComplete: function(storeKey, dataHash, newId) {
-    var status = this.readStatus(storeKey), K = SC.Record;
+    var status = this.readStatus(storeKey), K = SC.Record, statusOnly;
     
     // EMPTY, ERROR, READY_CLEAN, READY_NEW, READY_DIRTY, DESTROYED_CLEAN,
     // DESTROYED_DIRTY
     if (!(status & K.BUSY)) {
       throw K.BAD_STATE_ERROR; // should never be called in this state
-      
     }
     
     // otherwise, determine proper state transition
-    if(status==K.BUSY_DESTROYING) {
+    if(status===K.BUSY_DESTROYING) {
       throw K.BAD_STATE_ERROR ;
     } else status = K.READY_CLEAN ;
 
     this.writeStatus(storeKey, status) ;
     if (dataHash) this.writeDataHash(storeKey, dataHash, status) ;
     if (newId) SC.Store.replaceIdFor(storeKey, newId);
-    this.dataHashDidChange(storeKey);
+    
+    statusOnly = dataHash || newId ? NO : YES;
+    this.dataHashDidChange(storeKey, null, statusOnly);
     
     return this ;
   },
@@ -1419,10 +1664,15 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
       storeKey = recordType.storeKeyFor(id);
     }
     status = this.readStatus(storeKey);
-    if(status==K.EMPTY || status==K.ERROR || status==K.READY_CLEAN || status==K.DESTROY_CLEAN){ 
+    if(status==K.EMPTY || status==K.ERROR || status==K.READY_CLEAN || status==K.DESTROY_CLEAN) {
+      
       status = K.READY_CLEAN;
-      if(dataHash===undefined) this.writeStatus(storeKey, status) ;
-      else this.writeDataHash(storeKey, dataHash, status) ;
+      if(dataHash===undefined) {
+        this.writeStatus(storeKey, status) ;
+      }
+      else {
+        this.writeDataHash(storeKey, dataHash, status) ;
+      }
       this.dataHashDidChange(storeKey);
       
       return YES;
@@ -1432,7 +1682,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
   },
   
   pushDestroy: function(recordType, id, storeKey) {
-    var K = SC.Record;
+    var K = SC.Record, status;
 
     if(storeKey===undefined){
       storeKey = recordType.storeKeyFor(id);
@@ -1449,7 +1699,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
   },
 
   pushError: function(recordType, id, error, storeKey) {
-    var K = SC.Record;
+    var K = SC.Record, status;
 
     if(storeKey===undefined){
       storeKey = recordType.storeKeyFor(id);
@@ -1500,7 +1750,8 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
   },
   
   /**
-    Given a recordType and primaryKey, find the storeKey.
+    Given a recordType and primaryKey, find the storeKey. If the primaryKey 
+    has not been assigned a storeKey yet, it will be added.
     
     @param {SC.Record} recordType the record type
     @param {String} primaryKey the primary key
@@ -1508,6 +1759,71 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
   */
   storeKeyFor: function(recordType, primaryKey) {
     return recordType.storeKeyFor(primaryKey);
+  },
+  
+  /**
+    Given a primaryKey value for the record, returns the associated
+    storeKey.  As opposed to storeKeyFor() however, this method
+    will NOT generate a new storeKey but returned undefined.
+    
+    @param {String} id a record id
+    @returns {Number} a storeKey.
+  */
+  storeKeyExists: function(recordType, primaryKey) {
+    return recordType.storeKeyExists(primaryKey);
+  },
+  
+  /**
+    Finds all storeKeys of a certain record type in this store
+    and returns an array.
+    
+    @param {SC.Record} recordType
+    @returns {Array} set of storeKeys
+  */
+  storeKeysFor: function(recordType) {
+    var recType, ret = [], storeKey;
+    if(!this.statuses) return;
+    
+    for(storeKey in SC.Store.recordTypesByStoreKey) {
+      recType = SC.Store.recordTypesByStoreKey[storeKey];
+      // if same record type and this store has it
+      if(recType===recordType && this.statuses[storeKey]) {
+        ret.push(parseInt(storeKey,0));
+      }
+    }
+    
+    return ret;
+  },
+  
+  /**
+    Finds all storeKeys in this store
+    and returns an array.
+    
+    @returns {Array} set of storeKeys
+  */
+  storeKeys: function() {
+    var ret = [], storeKey;
+    if(!this.statuses) return;
+    
+    for(storeKey in this.statuses) {
+      // if status is not empty
+      if(this.statuses[storeKey] != SC.Record.EMPTY) {
+        ret.push(parseInt(storeKey,0));
+      }
+    }
+    
+    return ret;
+  },
+  
+  /**
+    Returns string representation of a storeKey, with status.
+    
+    @param {Number} storeKey
+    @returns {String}
+  */
+  statusString: function(storeKey) {
+    var rec = this.materializeRecord(storeKey);
+    return rec.statusString();
   }
   
 }) ;
@@ -1534,7 +1850,7 @@ SC.Store.mixin({
     a primaryKey and recordType that remains constant throughout the lifetime
     of the application.
   */
-  recordTypesByStoreKey: [],
+  recordTypesByStoreKey: {},
   
   /** @private
     The next store key to allocate.  A storeKey must always be greater than 0
@@ -1558,8 +1874,11 @@ SC.Store.mixin({
     Given a storeKey returns the SC.Record class associated with the key.
     If no record type is associated with the store key, returns null.
     
+    The SC.Record class will only be found if you have already called
+    storeKeyFor() on the record.
+    
     @param {Number} storeKey the store key
-    @returns {String} the primary key or null
+    @returns {SC.Record} the record type
   */
   recordTypeFor: function(storeKey) {
     return this.recordTypesByStoreKey[storeKey];
@@ -1585,8 +1904,7 @@ SC.Store.mixin({
     this.idsByStoreKey[storeKey] = primaryKey ;
     
     // then the other...
-    var storeKeys = recordType.storeKeysById ;
-    if (!storeKeys) storeKeys = recordType.storeKeysById = {};
+    var storeKeys = recordType.storeKeysById() ;
     delete storeKeys[oldPrimaryKey];
     storeKeys[primaryKey] = storeKey;     
     
@@ -1607,7 +1925,7 @@ SC.Store.mixin({
     this.recordTypesByStoreKey[storeKey] = recordType;
     return this ;
   }
-    
+  
 });