this.storage = new Offline.Storage("Files", this, { 
        keys: { folderId: folderCollection }, cascadeDelete: true
});

this.storage = new Offline.Storage("Files", this, { 
     keys: { folderId: folderCollection }, cascadeDelete: true, serverCascades: false
});

// Parent
    //Folder Collection
    var FolderCollection = Backbone.Collection.extend({  
        initialize: function (models, options) {
            var self = this;
            self.storage = new Offline.Storage("Folder", self);
        }
    });

    var folderCollection = new FolderCollection({ name: "Folder1"});

 // Child
    //Files Collection
    var FilesCollection = Backbone.Collection.extend({  
        initialize: function (models, options) {
            var self = this;
            self.storage = new Offline.Storage("Files", self, { keys: { folderId: folderCollection }, cascadeDelete: true });
        }
    });

    var fid = folderCollection.models[0].get("id");
    var filesCollection = new FilesCollection([
        { name: "File1", folderId: fid },
        { name: "File2", folderId: fid }
    ]);

// Cascade Delete - destroy the parent folder
    // when a folder is deleted from the FolderCollection there is a listener for the remove event
    // It loops the FileCollection and cascades a deletion on all models that have the folderId as the fk

    folderCollection.models[0].destroy({
        success: function (model, response) {
            // if autoPush is not turned on
            folderCollection.storage.sync.push();
            console.log("cascade complete");
        }
    });

[... Add to Storage, maybe after this.autoPush = options.autoPush || false; ... ]

// <cascade setup>
this.cascadeDelete = options.cascadeDelete || false; 
if ( this.cascadeDelete == true ) { 

    var parentCollection;
    var cascadeKey;
    var cascadeCollection = this.collection;
    var serverCascades = options.serverCascades || true;

    // loop keys to snag parentCollection and cascadeKey
    var _ref = this.keys;
    for (var field in _ref) {
        parentCollection = _ref[field];
        cascadeKey = field;
    }

    // console.log("parentCollection");
    // console.log(parentCollection);
    // console.log("cascadeKey");
    // console.log(cascadeKey);
    // console.log("cascadeCollection");
    // console.log(cascadeCollection);

    this.cascadeListener(parentCollection, cascadeCollection, cascadeKey, serverCascades);

}
// </ cascade setup >


[... After replaceKeyFields ... ]

///
/// < cascade functions >
/// Added for cascade deletes.
/// Pass in the parentModel that is being deleted.
/// If the model has cascadeDelete options passed it will cascade 
///    deletions down to all dependent child models in the cascadeCollection
///    based on the cascadeKey (this is usually the pk of the parentModel and the fk on the cascadeCollection model)
///    
    Storage.prototype.cascadeListener = function (parentCollection, cascadeCollection, cascadeKey, serverCascades) {
        // bind to this collections remove event so we can cascade deletes down to children
        var self = this;

        parentCollection.on("remove", function (parentModel) {
            console.log("parent model");
            console.log(parentModel);
            self.cascadeOnDelete(parentModel, cascadeCollection, cascadeKey, serverCascades);
        }, self);
    };

    Storage.prototype.cascadeOnDelete = function (parentModel, cascadeCollection, cascadeKey, serverCascades) {

        // when a model from parentCollection is deleted the cascadeOnDelete function is 
        // fired which loops all models in cascadeCollection where cascadeKey equals parentModelId
        // if serverCascades equals false or the parentModel is dirty then the child Models will be deleted
        // The case where the cascade will not occur is if serverCascades = true and the parent model is not dirty, 
        // meaning your sql server will take care of cascading the delteions for you. 

        var parentModelId = parentModel.get("id");
        var dirty = parentModel.get("dirty");

        whereClause = $.parseJSON('{"' + cascadeKey + '":"' + parentModelId + '"}');

        if (dirty == true || serverCascades == false) {
            console.log("whereClause");
            console.log(whereClause);

            _.each(cascadeCollection.where(whereClause), function (childModel) {
                console.log("deleting child model");
                console.log(childModel);
                childModel.destroy();
            });
        }
        else{
            console.log("the server will take of the cascade for you :)");
        }

    };
/// </ end cascade functions >

return Storage;

})();

[...]