gina 0.1.1-alpha.99 → 0.1.2-alpha.2

package/framework/{v0.1.1-alpha.99 → v0.1.2-alpha.2}/lib/collection/src/main.js

@@ -15,7 +15,7 @@ if ( typeof(module) !== 'undefined' && module.exports ) {
  * @param {object} [options]
  *
  * @returns {object} instance
- * 
+ *
  * Collection.length will return result length : dont't use .count() which is going to include functions to the count
  *
  * Collection::find
@@ -23,7 +23,7 @@ if ( typeof(module) !== 'undefined' && module.exports ) {
  *      eg.: { uid: 'someUID' }
  *      eg.: { type: 'not null', country: 'France' } // `AND` clause
  *      NB.: To filter `not empty`, use { type: '!=""' }
- *      eg.: { country: 'The Hashemite Kingdom of Jordan' }, { country: 'Libanon'} // `OR` clause 
+ *      eg.: { country: 'The Hashemite Kingdom of Jordan' }, { country: 'Libanon'} // `OR` clause
  *      eg.: { 'obj.prop': true }
  *      eg.: { 'contacts[*].name': 'Doe' } // `WITHIN` (array|collection) clause
  *      eg.: { lastUpdate: '>= 2016-12-01T00:00:00' }  // also available for date comparison `=`, `<`, `>`
@@ -48,7 +48,7 @@ function Collection(content, options) {
 
     var isGFFCtx        = ( ( typeof(module) !== 'undefined' ) && module.exports ) ? false : true;
     var uuid            = (isGFFCtx) ? require('vendor/uuid') : require('uuid');
-    var merge           = (isGFFCtx) ? require('utils/merge') : require('../../../lib/merge');
+    var merge           = (isGFFCtx) ? require('lib/merge') : require('../../../lib/merge');
 
     // defined search option rules
     var searchOptionRules = {
@@ -64,17 +64,17 @@ function Collection(content, options) {
     };
     var withOrClause = false;
     var notInSearchModeEnabled = false;
-    
+
     var localSearchOptions  = null;
-    
+
     var defaultOptions = {
         useLocalStorage: false,
         locale: 'en', // TODO - get settigs.region, or user.region
         searchOptionRules: searchOptionRules
     };
-    
-        
-    
+
+
+
     options = (typeof(options) == 'object') ? merge(options, defaultOptions) : defaultOptions;
 
     var keywords    = ['not null']; // TODO - null, exists (`true` if property is defined)
@@ -93,7 +93,7 @@ function Collection(content, options) {
         throw new Error('`new Collection([content] [, options] )`: `content` argument must be an Array !');
 
     content = (content) ? JSON.clone(content) : []; // original content -> not to be touched
-        
+
     // Indexing : uuids are generated for each entry
     var searchIndex = [], idx = 0;
     for (var entry = 0, entryLen = content.length; entry < entryLen; ++entry) {
@@ -106,16 +106,16 @@ function Collection(content, options) {
         ++idx;
     }
 
-    var instance = content;    
+    var instance = content;
     /**
      * Set local search option for the current collection method call
-     * 
-     * eg.: 
+     *
+     * eg.:
      *  var recCollection = new Collection(arrayCollection);
      *  var rec =  recCollection
      *                  .setSearchOption('name', 'isCaseSensitive', false)
      *                  .find({ city: 'cap Town' });
-     * 
+     *
      * eg.:
      *  var recCollection = new Collection(arrayCollection);
      *  var searchOptions = {
@@ -125,64 +125,64 @@ function Collection(content, options) {
      *  };
      *  var rec =  recCollection
      *                  .setSearchOption(searchOptions)
-     *                  .find({ city: 'cap Town' });     * 
-     * 
+     *                  .find({ city: 'cap Town' });     *
+     *
      * @param {object|string} searchOptionObject or searchOptionTargetedProperty
      * @param {string} [searchRule]
      * @param {boolean} [searchRuleValue] - true to enable, false to disabled
-     * 
+     *
      * @returns {object} instance with local search options
      */
     instance['setSearchOption'] = function() {
-        
+
         if (!arguments.length)
             throw new Error('searchOption cannot be left blank');
-            
+
         if (arguments.length > 3 || arguments.length < 3 && arguments.length > 1)
             throw new Error('argument length mismatch');
-        
+
         var i       = 0
             , len   = arguments.length
         ;
-        
+
         if (arguments.length == 1) {
             if ( typeof(arguments[0]) != 'object' )
                 throw new Error('searchOption must be an object');
-                
+
             for (var prop in arguments[0]) {
                 if ( typeof(searchOptionRules[prop]) == 'undefined' )
                     throw new Error(arguments[1] + ' is not an allowed searchOption !');
             }
-            
+
             localSearchOptions = arguments[0];
         } else {
-            
+
             if ( !localSearchOptions )
                 localSearchOptions = {};
-            
-            for (; i < len; ++i) {                
+
+            for (; i < len; ++i) {
                 if ( typeof(searchOptionRules[arguments[1]]) == 'undefined' )
                     throw new Error(arguments[1] + ' is not an allowed searchOption !');
-                
+
                 if (typeof(localSearchOptions[arguments[0]]) == 'undefined')
                     localSearchOptions[arguments[0]] = {};
-                
+
                 if ( /true|false/i.test(arguments[2]) ) {
                     localSearchOptions[arguments[0]][arguments[1]] = /true/i.test(arguments[2]) ? true : false
                 } else {
                     localSearchOptions[arguments[0]][arguments[1]] = arguments[2]
-                }                
+                }
             }
-        }    
-        
+        }
+
         return instance
     }
 
-    
+
     instance['find'] = function() {
-        // reset 
+        // reset
         withOrClause = false;
-        
+
         if ( typeof(arguments[arguments.length-1]) == 'boolean' ) {
             withOrClause = arguments[arguments.length-1];
             delete arguments[arguments.length-1];
@@ -197,13 +197,13 @@ function Collection(content, options) {
             filters         = JSON.parse(filtersStr);
             filtersCount    = filters.count();
         } catch( filtersError) {
-            throw new Error('filter must be an object\n'+ filtersError.stack);  
-        } 
-        
+            throw new Error('filter must be an object\n'+ filtersError.stack);
+        }
+
         if ( typeof(filters) != 'undefined' && filtersCount > 0 ) {
-            
+
             if (filtersCount > 1) {
-                withOrClause = true;                
+                withOrClause = true;
             }
             // checking filter : this should be forbidden -> { type: 'red', type: 'orange'}
             // var filtersFields = null;
@@ -216,7 +216,7 @@ function Collection(content, options) {
             //         filtersFields[ fField ] = true;
             //     }
             // }
-                        
+
             var filter              = null
                 , condition         = null
                 , i                 = 0
@@ -236,13 +236,13 @@ function Collection(content, options) {
             var matched = null
                 , filterIsArray = null
                 , searchResult = [];
-            
+
             /**
              *  Regular Search
-             * @param {object} filter 
-             * @param {string} field 
-             * @param {strine|number|date} _content 
-             * @param {number} matched 
+             * @param {object} filter
+             * @param {string} field
+             * @param {strine|number|date} _content
+             * @param {number} matched
              */
             var search = function(filter, field, _content, matched, searchOptionRules) {
                 var reValidCount = null, searchOptCount = null;
@@ -251,23 +251,23 @@ function Collection(content, options) {
                     ++matched;
 
                 } else if (
-                    filter 
-                    && keywords.indexOf(localeLowerCase) > -1 
-                    && localeLowerCase == 'not null' 
-                    && typeof(_content) != 'undefined' 
-                    && typeof(_content) !== 'object' 
-                    && _content != 'null' 
+                    filter
+                    && keywords.indexOf(localeLowerCase) > -1
+                    && localeLowerCase == 'not null'
+                    && typeof(_content) != 'undefined'
+                    && typeof(_content) !== 'object'
+                    && _content != 'null'
                     && _content != 'undefined'
                 ) {
-                    
+
                     if (result.indexOf(_content) < 0) {
                         ++matched;
                     }
 
-                } else if ( 
-                    typeof(_content) != 'undefined' 
-                    && typeof(_content) !== 'object' 
-                    && /(<|>|=)/.test(filter) 
+                } else if (
+                    typeof(_content) != 'undefined'
+                    && typeof(_content) !== 'object'
+                    && /(<|>|=)/.test(filter)
                     && !/undefined|function/.test(typeof(_content))
                 ) { // with operations
                     let originalFilter = filter;
@@ -281,7 +281,7 @@ function Collection(content, options) {
                         // restoring in case of datetime eval
                         filter = originalFilter;
                     }
-                    
+
                     // looking for a datetime ?
                     if (
                         /(\d{4})\-(\d{2})\-(\d{2})(\s+|T)(\d{2}):(\d{2}):(\d{2})/.test(_content)
@@ -296,44 +296,44 @@ function Collection(content, options) {
                         ++matched;
                     }
 
-                } else if ( 
-                    typeof(_content) != 'undefined' 
-                    && typeof(_content) !== 'object' 
+                } else if (
+                    typeof(_content) != 'undefined'
+                    && typeof(_content) !== 'object'
                     && _content === filter
                     && !searchOptions
                     ||
-                    typeof(_content) != 'undefined' 
-                    && typeof(_content) !== 'object' 
+                    typeof(_content) != 'undefined'
+                    && typeof(_content) !== 'object'
                     && _content === filter
                     && typeof(searchOptions[field]) == 'undefined'
                 ) {
 
                     ++matched;
-                } else if ( 
-                    typeof(_content) != 'undefined' 
-                    && typeof(_content) !== 'object' 
+                } else if (
+                    typeof(_content) != 'undefined'
+                    && typeof(_content) !== 'object'
                     && searchOptions
                     && typeof(searchOptions[field]) != 'undefined'
                 ) {
-                    
+
                     reValidCount    = 0;
                     searchOptCount  = searchOptions[field].count();
                     for ( var rule in searchOptions[field]) {
                         searchOptionRules[rule][searchOptions[field][rule]].re = searchOptionRules[rule][searchOptions[field][rule]].re.replace(/\%s/, filter);
-                        
+
                         if (searchOptionRules[rule][searchOptions[field][rule]].modifiers) {
-                            re = new RegExp(searchOptionRules[rule][searchOptions[field][rule]].re, searchOptionRules[rule][searchOptions[field][rule]].modifiers);   
+                            re = new RegExp(searchOptionRules[rule][searchOptions[field][rule]].re, searchOptionRules[rule][searchOptions[field][rule]].modifiers);
                         } else {
                             re = new RegExp(searchOptionRules[rule][searchOptions[field][rule]].re);
                         }
-                        
+
                         if ( re.test(_content) ) {
                             ++reValidCount
                         }
                     }
-                    
+
                     if (reValidCount == searchOptCount) {
-                        ++matched;    
+                        ++matched;
                     }
                 }
 
@@ -347,26 +347,26 @@ function Collection(content, options) {
                 var field = f.split(/\./g);
                 field = field[field.length - 1];
                 re = new RegExp('("' + field + '":\\w+)');
-                
+
                 var value = null;
-                
+
                 try {
                     if ( _content )
                         value = eval('_content.'+f);
                 } catch (err) {
                     // Nothing to do
                     // means that the field is not available in the collection
-                } 
-                
-                                   
+                }
+
+
 
                 if (value /** && value.length > 0*/) {
                     if ( Array.isArray(value) )
                         value = value[1].split(/:/)[1];
                     else if ( typeof(value) == 'string' && /\:/.test(value) )
                         value = value.split(/:/)[1];
-                    
-                    
+
+
                     if (/(<|>|=)/.test(filter)) {
 
                         // looking for a datetime ?
@@ -391,7 +391,7 @@ function Collection(content, options) {
                         }
                     }
 
-                }                
+                }
 
                 return {
                     matched: matched
@@ -400,25 +400,25 @@ function Collection(content, options) {
 
             // if one of the entry matches the given filter, tag the whole entry as matched
             var searchWithin = function(filter, f, _content, matched, i) {
-                
+
                 var collectionName  = null
                     , collection    = null
                     , arr           = null
                     , field         = null;
 
-               
+
                 arr = f.split(/\[\*\]/g);
                 collectionName = arr[0].replace(/\[\*\]/, '');// only take the first collection
                 collection = _content[ collectionName ];
-                
-                
+
+
                 field = arr[1];
                 if (/^\./.test(field) )
                     field = field.substr(1);
 
                 var subMatched = 0;
                 if (collection) {
-                    
+
                     for (var c = 0, cLen = collection.length; c < cLen; ++c) {
                         // cases with _filter.prop
                         if (/\./.test(field)) {
@@ -435,32 +435,32 @@ function Collection(content, options) {
                         if (subMatched > 0) break;
                     }
                 }
-                
+
                 return {
                     matched: (matched + subMatched)
                 }
             }
 
-            
+
             for (var o in tmpContent) {
 
                 if (!tmpContent[o]) {
                     tmpContent[o] = {}
                 }
-                
+
                 if (!/undefined|function/.test( typeof(tmpContent[o]))) {
-                    
+
                     for (let l = 0, lLen = filters.count(); l<lLen; ++l) {
                         filter = filters[l];
                         condition = filter.count();
-                        // for each condition 
+                        // for each condition
                         matched = 0;
-                        
+
                         for (var f in filter) {
                             if ( typeof(filter[f]) == 'undefined' ) throw new Error('filter `'+f+'` cannot be left undefined');
 
                             localeLowerCase = ( filter[f] !== null && !/(boolean|number)/.test(typeof(filter[f])) ) ? filter[f].toLocaleLowerCase() : filter[f];
-                            
+
                             // cases with tmpContent.prop
                             if (/\./.test(f)) {
                                 //JSON.stringify(tmpContent[o]).match(/("gross":\w+)/)[1].split(/:/)[1]
@@ -478,19 +478,19 @@ function Collection(content, options) {
                                 }
 
                             } else { // normal case
-                                                                    
-                                searchResult = search(filter[f], f, tmpContent[o][f], matched, searchOptionRules);                                
+
+                                searchResult = search(filter[f], f, tmpContent[o][f], matched, searchOptionRules);
                                 matched = searchResult.matched;
-                            }                            
+                            }
                         }
 
                         if (matched == condition ) { // all conditions must be fulfilled to match
                             // `this` {Array} is the result of the previous search or the current content
-                            // TODO - Add a switch                             
+                            // TODO - Add a switch
                             if (
-                                withOrClause 
+                                withOrClause
                                 && notInSearchModeEnabled
-                                && searchIndex.indexOf(tmpContent[o]._uuid) < 0 
+                                && searchIndex.indexOf(tmpContent[o]._uuid) < 0
                                 || notInSearchModeEnabled
                                 || !withOrClause
                             ) {
@@ -506,12 +506,12 @@ function Collection(content, options) {
                                 if (result.indexOf(tmpContent[o]._uuid) < 0) {
                                     result[i] = tmpContent[o];
                                     ++i;
-                                }   
+                                }
                             }
                         }
 
                     }
-                    
+
                 }
             }
         } else {
@@ -520,7 +520,7 @@ function Collection(content, options) {
 
         // reset localSearchOptions for nest calls
         localSearchOptions = null;
-        
+
         // TODO - remove this
         //if (withOrClause) {
             // merging with previous result
@@ -530,13 +530,13 @@ function Collection(content, options) {
             // }
             // TODO - remove this part
             // Removed this on 2021-01-21 because it was causing duplicate content
-            //result  = merge(this, result, true)            
+            //result  = merge(this, result, true)
         //}
 
         // chaining
         //result._options         = instance._options;
         //result.setSearchOption  = instance.setSearchOption;
-        
+
         result.insert           = instance.insert;
         result.notIn            = instance.notIn;
         result.find             = this.find;
@@ -552,24 +552,24 @@ function Collection(content, options) {
 
         return result
     }
-    
-    /** 
+
+    /**
      * findOne
-     * 
-     * E.g.: 
+     *
+     * E.g.:
      *  - new Collection(projects).findOne({name: 'My Project'})
      *  - new Collection(projects)
      *              .setSearchOption({name: { isCaseSensitive: false }})
      *              .findOne({name: 'my project'})
-     * 
-     * 
+     *
+     *
      * Available options :
      *  isCaseSensitive: [true|false] - set to true by default
-     * 
+     *
      * @param {object} filter
-     * 
+     *
      * @returns {object} result
-     * 
+     *
     */
     instance['findOne'] = function() {
         var key         = null // comparison key
@@ -583,17 +583,17 @@ function Collection(content, options) {
             delete arguments[arguments.length - 1];
             --arguments.length;
         }
-        
+
         // if ( typeof(arguments[arguments.length-1]) == 'boolean' ) {
         //     uuidSearchModeEnabled = arguments[arguments.length - 1]
         //     delete arguments[arguments.length - 1];
         //     --arguments.length;
         // }
-        
+
         if (arguments.length > 0) {
             filters = arguments;
         }
-        
+
 
         if ( typeof(filters) == 'undefined' || !filters || typeof(filters) != 'object' ) {
             throw new Error('[ Collection ][ findOne ] `filters` argument must be defined: Array or Filter Object(s) expected');
@@ -608,9 +608,9 @@ function Collection(content, options) {
         } else {
             foundResults = instance.find.apply(this, arguments) || [];
         }
-        
+
         if (foundResults.length > 0) {
-            currentResult = foundResults.limit(1).toRaw()[0];            
+            currentResult = foundResults.limit(1).toRaw()[0];
         }
 
         result          = currentResult;
@@ -649,31 +649,31 @@ function Collection(content, options) {
 
         return result
     }
-    
-    /** 
+
+    /**
      * notIn
      * Works like a filter to match results by `excluding` through given `filters` !!
-     * 
-     *  filter can be like 
+     *
+     *  filter can be like
      *      { car: 'toyota' }
      *      { car: 'toyota', color: 'red' }
-     *      
+     *
      *  You can pass more than one filter
      *      { car: 'toyota', color: 'red' }, { car: 'porche' }
-     * 
+     *
      * .notIn(filter) // AND syntax
      * .notIn(filter1, filter2, filter3) // OR syntax
      * .notIn(filter, 'id') where `id` is the uuid used for the DIFF - `_uuid
      * .noIn(collectionObj, 'id')
-     * 
+     *
      * By default, Collection use its own internal `_uuid` to search and compare.
      * This mode is called `uuidSearchModeEnabled`, and it is by default set to `true`.
      * If you want to disable this mode in order to MATCH/DIFF by forcing check on every single filter
      * of the resultset :
      *      .notIn(filter, false) where false must be a real boolean
-     * 
-     * 
-     * 
+     *
+     *
+     *
      * @param {object|array} filters|arrayToFilter - works like find filterss
      * @param {string} [key] - unique id for comparison; faster when provided
     */
@@ -691,17 +691,17 @@ function Collection(content, options) {
             delete arguments[arguments.length - 1];
             --arguments.length;
         }
-        
+
         if ( typeof(arguments[arguments.length-1]) == 'boolean' ) {
             uuidSearchModeEnabled = arguments[arguments.length - 1]
             delete arguments[arguments.length - 1];
             --arguments.length;
         }
-        
+
         if (arguments.length > 0) {
             filters = arguments;
         }
-        
+
 
         if ( typeof(filters) == 'undefined' || !filters || typeof(filters) != 'object' ) {
             throw new Error('[ Collection ][ notIn ] `filters` argument must be defined: Array or Filter Object(s) expected');
@@ -709,7 +709,7 @@ function Collection(content, options) {
 
         // If an operation (find, insert ...) has been executed, get the previous result; if not, get the whole collection
         var currentResult = JSON.clone( (Array.isArray(this)) ? this : content );
-        
+
         var foundResults = null;
         if ( Array.isArray(arguments[0]) ) {
             foundResults    = arguments[0];
@@ -718,16 +718,16 @@ function Collection(content, options) {
             foundResults    = instance.find.apply(this, arguments) || [];
             notInSearchModeEnabled = false;
         }
-        
-        
+
+
         if (foundResults.length > 0) {
-            
+
             // check key
-            if ( 
+            if (
                 uuidSearchModeEnabled
-                && key 
-                && typeof(foundResults[0]) == 'undefined' 
-                && typeof(foundResults[0][key]) == 'undefined' 
+                && key
+                && typeof(foundResults[0]) == 'undefined'
+                && typeof(foundResults[0][key]) == 'undefined'
             ) {
                 throw new Error('[ Collection ][ notIn ] `key` not valid');
             } else if ( uuidSearchModeEnabled && !key && typeof(foundResults[0]['_uuid']) != 'undefined' ) {
@@ -735,10 +735,10 @@ function Collection(content, options) {
             } else if ( typeof(foundResults[0]['id']) != 'undefined' ) {
                 key = 'id';
             }
-            
+
             if ( !key || typeof(foundResults[0][key]) == 'undefined' ) {
                 throw new Error('No comparison key defined !')
-            } 
+            }
 
             // fast search with key
             var r       = 0
@@ -752,17 +752,17 @@ function Collection(content, options) {
                 , fullFiltersMatched = 0
             ;
             if ( uuidSearchModeEnabled && typeof(currentResult[c]) != 'undefined' && currentResult[c].hasOwnProperty(key) ) {
-                // for every single result found        
+                // for every single result found
                 for (; r < rLen; ++r) {
-                    
+
                     if (!currentResult.length) break;
-                    
+
                     c = 0; cLen = currentResult.length;
                     for (; c < cLen; ++c) {
                         if ( typeof(currentResult[c]) == 'undefined' || typeof(foundResults[r]) == 'undefined' ) {
                             continue
                         }
-                        // when matched, we want to remove those not in current result                        
+                        // when matched, we want to remove those not in current result
                         if (currentResult[c][key] === foundResults[r][key]) {
                             currentResult.splice(c,1);
                             break;
@@ -772,48 +772,48 @@ function Collection(content, options) {
             } else if ( typeof(currentResult[c]) == 'undefined' ) { //empty source case
                 // means that since we don't have a source to compare, current === found
                 currentResult = JSON.clone(foundResults);
-                
+
             } else { // search based on provided filters
-                // for every single result found        
+                // for every single result found
                 for (; r < rLen; ++r) {
-                    if (!currentResult.length) break;                    
-                    
+                    if (!currentResult.length) break;
+
                     //onRemoved:
                     c = 0; cLen = currentResult.length;
-                    for (; c < cLen; ++c) { // current results                        
-                
+                    for (; c < cLen; ++c) { // current results
+
                         if ( typeof (currentResult[c]) != 'undefined' ) {
-                            
+
                             // for each filter
-                            fullFiltersMatched = 0;  
-                            f = 0;  
+                            fullFiltersMatched = 0;
+                            f = 0;
                             for (; f < fLen; ++f ) {
                                 if ( typeof(filters[f]) == 'undefined' ) throw new Error('filter `'+f+'` cannot be left undefined');
-                                
+
                                 keyLen = filters[f].count();
                                 matched = 0;
                                 for (key in filters[f]) {
                                     if ( currentResult[c].hasOwnProperty(key) && currentResult[c][key] === foundResults[r][key] ) {
                                         ++matched;
-                                    }   
-                                }    
+                                    }
+                                }
                                 if (matched == keyLen) {
                                     ++fullFiltersMatched
-                                }              
+                                }
                             }
-                            
+
                             if (fullFiltersMatched) {
                                 currentResult.splice(c,1);
                                 //break onRemoved;
                                 break;
                             }
-                            
+
                         }
                     }
                 }
-            }   
-                
-        } 
+            }
+
+        }
 
         result          = currentResult;
         result.notIn    = instance.notIn;
@@ -866,12 +866,12 @@ function Collection(content, options) {
 
     /**
      * update
-     * 
+     *
      * @param {object} filter
      * @param {object} set
-     * 
+     *
      * @returns {objet} instance
-     */    
+     */
     instance['update'] = function() {
         var key         = '_uuid' // comparison key is _uuid by default
             , result    = null
@@ -880,34 +880,34 @@ function Collection(content, options) {
             //, uuidSearchModeEnabled = true
         ;
 
-        // comparison key  : _uuid by default, but can be set to id        
+        // comparison key  : _uuid by default, but can be set to id
         if ( typeof(arguments[arguments.length-1]) == 'string' ) {
             key = arguments[arguments.length - 1];
             delete arguments[arguments.length - 1];
             --arguments.length;
-        } 
-        
+        }
+
         if ( typeof(arguments[arguments.length-1]) == 'object' ) {
             set = arguments[arguments.length - 1];
             delete arguments[arguments.length - 1];
             --arguments.length
         }
-        
+
         // if ( typeof(arguments[arguments.length-1]) == 'boolean' ) {
         //     uuidSearchModeEnabled = arguments[arguments.length - 1]
         //     delete arguments[arguments.length - 1];
         //     --arguments.length;
         // }
-        
+
         if (arguments.length > 0) {
             filters = arguments;
         }
-        
+
 
         if ( typeof(filters) == 'undefined' || !filters || typeof(filters) != 'object' ) {
             throw new Error('[ Collection ][ update ] `filters` argument must be defined: Array or Filter Object(s) expected');
         }
-        
+
         if ( typeof(set) == 'undefined' || !set || typeof(set) != 'object' ) {
             throw new Error('[ Collection ][ update ] `set` argument must be defined: Object expected');
         }
@@ -919,23 +919,24 @@ function Collection(content, options) {
         } else {
             foundResults = instance.find.apply(this, arguments) || [];
         }
-        
+
         result = Array.isArray(this) ? this : JSON.clone(content);
-        if (foundResults.length > 0 ) {          
+        if (foundResults.length > 0 ) {
             var arr = foundResults.toRaw();
-            for (var a = 0, aLen = arr.length; a < aLen; ++a) {                
-                arr[a] = merge( JSON.clone(set), arr[a]);
+            for (var a = 0, aLen = arr.length; a < aLen; ++a) {
+                arr[a] = merge(JSON.clone(set), arr[a]);
+                // arr[a] = merge(set, arr[a]);
                 for (var r = 0, rLen = result.length; r < rLen; ++r) {
                     if ( typeof(result[r][key]) == 'undefined' && key == '_uuid' && typeof(result[r]['id']) != 'undefined' ) {
                         key = 'id';
                     }
-                    
+
                     if ( result[r][key] == arr[a][key] ) {
                         result[r] = arr[a];
                         break;
                     }
                 }
-            }            
+            }
         }
 
         // chaining
@@ -954,8 +955,8 @@ function Collection(content, options) {
 
         return result
     }
-    
-    
+
+
     instance['replace'] = function() {
         var key         = '_uuid' // comparison key
             , result    = null
@@ -964,34 +965,34 @@ function Collection(content, options) {
             //, uuidSearchModeEnabled = true
         ;
 
-                
+
         if ( typeof(arguments[arguments.length-1]) == 'string' ) {
             key = arguments[arguments.length - 1];
             delete arguments[arguments.length - 1];
             --arguments.length;
-        } 
-        
+        }
+
         if ( typeof(arguments[arguments.length-1]) == 'object' ) {
             set = arguments[arguments.length - 1];
             delete arguments[arguments.length - 1];
             --arguments.length;
         }
-        
+
         // if ( typeof(arguments[arguments.length-1]) == 'boolean' ) {
         //     uuidSearchModeEnabled = arguments[arguments.length - 1]
         //     delete arguments[arguments.length - 1];
         //     --arguments.length;
         // }
-        
+
         if (arguments.length > 0) {
             filters = arguments;
         }
-        
+
 
         if ( typeof(filters) == 'undefined' || !filters || typeof(filters) != 'object' ) {
             throw new Error('[ Collection ][ update ] `filters` argument must be defined: Array or Filter Object(s) expected');
         }
-        
+
         if ( typeof(set) == 'undefined' || !set || typeof(set) != 'object' ) {
             throw new Error('[ Collection ][ update ] `set` argument must be defined: Object expected');
         }
@@ -1005,25 +1006,25 @@ function Collection(content, options) {
         } else {
             foundResults = instance.find.apply(this, arguments) || [];
         }
-        
+
         result = Array.isArray(this) ? this : JSON.clone(content);
-        if (foundResults.length > 0 ) {          
+        if (foundResults.length > 0 ) {
             var arr = foundResults.toRaw();
-            for (var a = 0, aLen = arr.length; a < aLen; ++a) {                
+            for (var a = 0, aLen = arr.length; a < aLen; ++a) {
                 arr[a] = JSON.clone(set);
                 for (var r = 0, rLen = result.length; r < rLen; ++r) {
                     if ( typeof(result[r][key]) == 'undefined' && key == '_uuid' && typeof(result[r]['id']) != 'undefined' ) {
                         key = 'id';
                     } else if (typeof(result[r][key]) == 'undefined' && key == '_uuid') {
                         throw new Error('No comparison key defined !')
-                    } 
-                    
+                    }
+
                     if ( result[r][key] == arr[a][key] ) {
                         result[r] = arr[a];
                         break;
                     }
                 }
-            }            
+            }
         }
 
         // chaining
@@ -1042,24 +1043,24 @@ function Collection(content, options) {
 
         return result
     }
-    
+
     /**
      * .delete({ key: 2 })
      * .delete({ name: 'Jordan' }, ''id) where id will be use as the `uuid` to compare records
-     * 
+     *
      * AND syntax
      * .delete({ car: 'toyota', color: 'red' })
-     * 
+     *
      * OR syntax
      * .delete({ car: 'toyota', color: red }, { car: 'ford' } ) // will delete all `toyota red cars` & all `ford cars`
-     * 
+     *
      *  N.B.: will not affect current result - just returning the DIFF
      *  If you
      * @param {object} filter - samme as `.find(filter)`
      * @param {string|boolean} [ uuid | disabled ] - by default, Collection is using its internal _uuid
      * If you want to delete without key comparison, disable `uuid` search mode
      * .delete({ name: 'Jordan' }, false)
-     * 
+     *
      * @returns {array} result
      */
     instance['delete'] = function() {
@@ -1090,10 +1091,10 @@ function Collection(content, options) {
      * @param {object|array} filter
      * */
     instance['orderBy'] = function () {
-        
+
         if ( typeof(arguments) == 'undefined' || arguments.length < 1)
             throw new Error('[ Collection->orderBy(filter) ] where `filter` must not be empty or null' );
-            
+
         var filter = null;
         if ( arguments.length == 1 ) {
             filter = arguments[0];
@@ -1108,27 +1109,27 @@ function Collection(content, options) {
         var variableContent = (Array.isArray(this)) ? this : JSON.clone(content);
         return sortResult(filter, variableContent.toRaw())
     }
-    
+
     /**
      * max
-     * E.g: 
+     * E.g:
      *  myCollection.max({ order: 'not null'})
      *      => 5
      *  myCollection.max({ createAt: 'not null'})
      *      => '2021-12-31T23:59:59'
      *  myCollection.max({ firstName: 'not null'})
      *      => 'Zora'
-     * 
+     *
      * @param {object|array} filter
-     * 
+     *
      * @returns {number|date|string}
      * */
     instance['max'] = function () {
         if ( typeof(arguments) == 'undefined' || arguments.length < 1)
             throw new Error('[ Collection->max(filter) ] where `filter` must not be empty or null' );
-        
+
         var filter = null;
-        if ( 
+        if (
             arguments.length > 1
             || Array.isArray(arguments[0])
             || typeof(arguments[0]) == 'object' && arguments[0].count() > 1
@@ -1157,11 +1158,11 @@ function Collection(content, options) {
      *
      *  // overriding filters -> last filter is always right
      *  .orderBy([ { updatedAt : 'desc'}, { name: 'asc' } ])
-     * 
-     *  // sorting boolean 
+     *
+     *  // sorting boolean
      *  .orderBy({ isActive: 'desc'}) => will display all active(TRUE) first
      *  NB.: Boolean are 0 (FALSE) or 1 (TRUE)
-     * 
+     *
      *  // combining filters -> the first one is always right
      *  .orderBy({ updatedAt : 'desc'}, { name: 'asc' })
      *
@@ -1193,33 +1194,33 @@ function Collection(content, options) {
                 _m[prop] = obj[prop];
                 return _m;
             });
-            
-            mapped.sort(function onAscSort(a, b) {    
-                
-                
+
+            mapped.sort(function onAscSort(a, b) {
+
+
                 var _compare = function(a, b) {
                     // handle booleans
                     if ( /^(true|false)$/i.test(a) ) {
                         a = ( /true/i.test(a) ) ? 1 : 0;
                     }
-                    
+
                     if ( /^(true|false)$/i.test(b) ) {
                         b = ( /true/i.test(b) ) ? 1 : 0;
                     }
-                    
-                    
+
+
                     if ( typeof(a) == 'string' && a != '' ||  typeof(b) == 'string' ) {
-                        
+
                         if ( typeof(a) == 'number' ) {
                             a = ''+a; // cast to string
-                        } 
+                        }
                         if ( typeof(b) == 'number' ) {
                             b = ''+b; // cast to string
-                        } 
-                        
+                        }
+
                         return a.localeCompare(b, undefined, {sensitivity: 'case', caseFirst: 'upper'})
                     }
-                    
+
                     if (a > b) {
                         return 1;
                     }
@@ -1227,18 +1228,18 @@ function Collection(content, options) {
                         return -1;
                     }
                     // a must be equal to b
-                    return 0;                    
+                    return 0;
                 }
-                
-                
+
+
                 if ( typeof(a) == 'object' ) {
                     return _compare(a[prop], b[prop])
                 }
-                
+
                 return _compare(a, b)
-                    
+
             });
-            
+
             return mapped.map(function(m, index, result){
                 return content[m.index];
             });
@@ -1250,24 +1251,24 @@ function Collection(content, options) {
         }
 
         multiSortOp = function(content, filter) {
-            
+
             var props = [], keys = [];
-            
+
             if ( Array.isArray(filter) ) {
                 for (var f = 0, fLen = filter.length; f < fLen; ++f) {
                     props[f] = Object.keys(filter[f])[0];
-                    keys[f] = filter[f][ props[f]] ;     
+                    keys[f] = filter[f][ props[f]] ;
                 }
             } else {
                 var f = 0;
                 for (var flt in filter) {
                     props[f] = flt;
-                    keys[f] = filter[flt] ;  
+                    keys[f] = filter[flt] ;
                     ++f;
                 }
             }
-            
-            
+
+
 
             sortRecursive = function(a, b, columns, order_by, index) {
 
@@ -1284,7 +1285,7 @@ function Collection(content, options) {
                     } else if (res != 0) {
                         return res < 0 ? 1 : -1
                     }
-                    
+
                     // a must be equal to b
                     return columns.length - 1 > index ? sortRecursive(a, b, columns, order_by, index + 1) : 0;
 
@@ -1345,11 +1346,11 @@ function Collection(content, options) {
         }
 
         if ( Array.isArray(filter) || filter.count() > 1 ) {
-            
+
             result = multiSortOp(content, filter);
-            
+
         } else {
-                        
+
             prop    = Object.keys(filter)[0];
             key     = filter[prop];
 
@@ -1371,7 +1372,7 @@ function Collection(content, options) {
         result.max      = instance.max;
         result.toRaw    = instance.toRaw;
         result.filter   = instance.filter;
-        
+
         return result
     };
 
@@ -1383,16 +1384,18 @@ function Collection(content, options) {
      * */
     instance['toRaw'] = function() {
 
-        var result = ( Array.isArray(this) ) ? this : content;
+        var result = ( Array.isArray(this) ) ? this.slice() : content.slice();
         // cleanup
         for (var i = 0, len = result.length; i < len; ++i) {
             if (result[i]._uuid)
                 delete result[i]._uuid;
+
         }
 
-        return JSON.clone(result);
+        // return JSON.clone(result);
+        return result
     }
-    
+
     /**
      * filter
      * Reduce record propName
@@ -1403,7 +1406,7 @@ function Collection(content, options) {
      * @returns {array} rawFilteredResult
      * */
      instance['filter'] = function(filter) {
-        
+
         if ( typeof(filter) == 'undefined' ) {
             throw new Error('`filter` parametter must be a string or an array.');
         }
@@ -1413,7 +1416,7 @@ function Collection(content, options) {
         }
         var i = 0, len = result.length;
         var rawFilteredResult = [], fCount = 0;
-                
+
         if ( Array.isArray(filter) ) {
             var f = null, fLen = filter.length, wrote = null;
             for (; i < len; ++i) {
@@ -1441,12 +1444,12 @@ function Collection(content, options) {
                     ++fCount;
                 }
             }
-        }            
+        }
 
         return JSON.clone(rawFilteredResult);
     }
-    
-    
+
+
     return instance;
 };