https://github.com/ClickerMonkey/neurosync/tree/master/test#neuromodel-instance-functions

https://github.com/ClickerMonkey/neurosync/tree/master/test#neuro-hasmany-options

Instead of sending only changed fields on NeuroRemoteSave, send all fields.

• Add get(key) to Neuro.rest and Neuro.store
• When grabModel is called & lazy is true, make REST call to fetch object.
• Maybe make store.get call first?
• When lazy, don't call store.all in NeuroDatabase.init.

Possible options

• [0] None
• [1] Local
• [2] Rest
• [4] Live
• [6] Remote (rest & live)
• [7] All (rest, local & live)

That way you can do things like Neuro.Cascade.Local | Neuro.Cascade.Live if you wanted (uses bitwise operations to determine what to do).

NeuroOperations will need to accept a new parameter called cascade.

https://github.com/ClickerMonkey/neurosync/tree/master/test#neuro-hasmanythrough-options

Instead of Neuro.rest(database)(options, success, failure) it will have the format Neuro.rest(database)(method, model, data, success, failure)

This will be useful for models that aren't loaded remotely, but are loaded by a related model (like a 1-to-many)

This will be useful if the same object is stored in a relationship and other relationships and it's table. We need a way to determine the values to use.

Acceptable values are a field name or a function which accepts a model.

A model can be related to multiple models based on discriminating id & type.

nameOfMorph: {
  fields: 'parent_id', // field or fields that point to related object
  discriminator: 'parent_type', // field that determines the 
  mapping: { // a mapping from discriminator to the class
    'discriminator_value': DiscriminatedClass
  }
}

A model can reference a discriminated model

nameOfRelatedMorph: {
   model: ClassWithDiscriminator,
   morph: 'nameOfMorphInClassAbove',
}

Add ready function which triggers a given function when the database has loaded. If the database is already loaded, the function should be invoked immediately. If the given function returns === false then we need to remove the listener.

This will be useful for relationships - they can't fetch related models until they know the related database has been loaded.

https://github.com/ClickerMonkey/neurosync/tree/master/test#neuromodel-save-cases

The results of $key is not necessarily the key of the model - since the model can have a composite key. It would be better to call this hash/$hash throughout the code to be clearer.

Instead of a factory which returns a single function, return an object which has the methods:

• all
• create
• update
• remove

Utilize this method in the NeuroSaveRemote operation.

As soon as there's a successful remote save, remove it locally.

• Setup test folder.
• Use QUnit.
• Create store, rest, & live implementations that can easily be modified outside of neurosync to simulate real world services.
• More Issues to come to cover individual areas of the code base.

Add a function called Neuro.store like Neuro.rest which is responsible for returning a storage implementation.

For example:

Neuro.store = function(database) // NeuroDatabase
{
  return {
    put: function(key, record, success, failure) { },
    remove: function(key, success, failure) { },
    all: function(success, failure) { }
  };
};

The use of promises in NeuroDatabase.js will have to be refactored as well to be decoupled from StorkJS.

Should be used to populate default values on every NeuroDatabase instance created. This will remove the odd db.cache !== false logic.

https://github.com/ClickerMonkey/neurosync/tree/master/test#neuro-functions

https://github.com/ClickerMonkey/neurosync/tree/master/test#neuro-hasone

https://github.com/ClickerMonkey/neurosync/tree/master/test#neuro-instance-functions

https://github.com/ClickerMonkey/neurosync/tree/master/test#neuro-hasmany

In the event that the device's local storage implementation can't fit all of the models for an application in the cache - add an $age to all models (time in millis or a counter will suffice) and a method to $touch() a model which updates it's age to avoid removal.

This will increase user experience by keeping the most frequently used models in local storage in the event of offline usage.

Not sure how we will communicate to the developer/user that a database is missing models because they weren't recently used enough.

The key option passed to Neuro should allow arrays. This also requires that a new option be added called keySeparator which is used to take multiple columns and combine them together into a single key string.

https://github.com/ClickerMonkey/neurosync/tree/master/test#neuro-hasmanythrough

And all subsequent NeuroRelation implementations.

. Event description (event data)

NeuroModel events

1. Remote data has been received and a model has partially been updated (fields updated, fields with local changes)
2. Remote data has been received and a model has fully been updated (fields updated)
3. Remote data has been received and a model has been updated (fields sent) - always triggered after 1. or 2.
4. Remote removal

NeuroDatabase events

1. Model added (model)
2. Model removed (model)
3. Model updated (model)

https://github.com/ClickerMonkey/neurosync/tree/master/test#neurodatabase-instance-functions

Add nullsFirst option to NeuroDatabase.setComparator and subseqeuently to compare function.

An option called comparatorNullsFirst can be passed to Neuro which is passed to the initial setComparator function.

https://github.com/ClickerMonkey/neurosync/tree/master/test#neuro-live

Additional Items:

• Listen to relation-update in NeuroBind

Possible parameters:

Example User model has many Groups through UserGroups

hasManyThrough: {
  groups: {
    local: 'user_id',
    model: Group,
    foreign: 'group_id'
    through: UserGroup,
    cascadeRemove: true,
    cascadeSave: true,
    comparator: ...,
    property: ...,
    save: ...,
    store: ...
  }
}

• If through has a model added AND it's related to the model AND its not a related model that is already related, add it.
• If through has a model removed AND it's related to the model AND its already related, remove it.

https://github.com/ClickerMonkey/neurosync/tree/master/test#neuro-options

When data is loaded locally/remotely the hasManyThrough relationships don't contain ALL related models.

Add options to pass to Neuro function called belongsTo, hasOne, hasMany, hasManyThrough

• Every relationship has a property on the model to which it's stored on.
• Options should be available to either store the object or it's ID in the property.
• belongsTo and hasOne refers to a single item where hasMany and hasManyThrough is an array. - Options should be available to send or not send the property the rest/live services.
• Options should be available to load models from rest/live services.
• belongsTo has a key on the current model that points to another model. The other model may have a hasMany relationship back.
• hasOne has a key on the current model that points to another model. The other model most likely doesn't have a hasMany relationship back because it typically doesn't know who it belongs to. When a relationship is removed from the model the related model is permanently deleted. A cascade = false option can be specified to override this functionality.
• hasMany has a key on the related model - so when a relationship is removed from the model the related model is permanently deleted. A cascade = false option can be specified to override this functionality.
• belongsTo has an option to add a discriminator column and map of Model types based on the discriminated value.
• When a model is removed that has belongsTo relationships, clear the property on the related model.
• When a model is removed that has hasOne relationship & cascade !== false, remove the related model.
• When a model is removed that has a hasMany relationship & cascade !== false, remove all related models.
• When a model is removed that has a hasManyThrough relationship, remove all related relation models.

Implementation

Add a NeuroRelationship class which provides the following functions (names pending):

{
  init: function(model, database, options) {},
  relate: function(model or key) {},
  unrelate: function(model or key) {},
  set: function(models or keys) {},
  save: function(model)
}

This is useful if we wan't to require internet access for models OR if a model is actually stored on a relationship.

https://github.com/ClickerMonkey/neurosync/tree/master/test#neuro-belongsto-options

Similar to Neuro.rest, add a function called Neuro.live which takes the NeuroDatabase and a callback function which is passed published messages. It should return a function which accepts messages to publish.

Neuro.live = function(database, onMessage)
{
  // implement
  return functionThatSendsMessages;
};

database has the options passed into Neuro as properties - so anything passed in as options is accessible via database.option.

1. Cache comparator function
2. Add setComparator to NeuroDatabase (which does the caching)
3. Add isSorted to NeuroDatabase
4. Add smart sorting, that only sorts when the database is out of order

https://github.com/ClickerMonkey/neurosync/tree/master/test#neuromodel-remove-cases

https://github.com/ClickerMonkey/neurosync/tree/master/test#neuro-belongsto

var model = Neuro.create(properties) is shorthand for:

var model = new Neuro(properties);
model.$save();

Instead of model.$relate( 'prop', related ); you should be able to do model.prop.relate( related ). (given they have property set to true on the relation).

https://github.com/ClickerMonkey/neurosync/tree/master/test#neuro-hasone-options

When an offline event triggers, listen for an online event. Once the online event triggers call NeuroDatabase.refresh(). Ideally we should wait until all other listeners have been triggered, wouldn't want to refresh before all saves & deletes have processed.

Instead of sending only differing fields on a live publish, send all in NeuroSaveRemote. Similar to #24