elderwand 0.1.75 → 0.1.78

package/Environment/environment.js

@@ -31,7 +31,7 @@ module.exports = function(){
         }
     });
     addPropertyToClass(global, '__line', undefined,{
-        gçet: function(){
+        get: function(){
             return __stack[1].getLineNumber();
         }
     });
@@ -54,7 +54,7 @@ module.exports = function(){
     addPropertyToClass(global, "EWLog", function(){
         var date = new Date();
         var dateStr = date.getHours() + ":" + date.getMinutes() + ":" + date.getSeconds() + ":"+ date.getMilliseconds()
-        var args = [dateStr,__caller];
+        var args = [dateStr, __caller];
         for(var key in arguments){
             args.push(arguments[key]);
         }

package/NoDuplicate/README.md

@@ -1,68 +1,116 @@
-[![Build Status](https://travis-ci.org/riyadhalnur/mongoose-softdelete.svg?branch=master)](https://travis-ci.org/riyadhalnur/mongoose-softdelete)
+# elderwand-mongoose-no-duplicate
 
-Mongoose Soft Delete Plugin
-============================
+A Mongoose plugin that prevents duplicate documents by hashing a document's
+content into a unique-indexed `sha1_hash` field. When two documents would
+have the same content, the second `.save()` is rejected by MongoDB with a
+duplicate-key error.
 
-Mongoose plugin that enables soft deletion of Models/Documents.  
+## How it works
 
-This plugin is based on the work of [Yi](https://github.com/yi).  
+1. The plugin adds a `sha1_hash: String` field with `unique: true`.
+2. On every `.save()`, a `pre('save')` hook computes
+   `sha1(JSON.stringify(model.toObject()))` with selected fields excluded or
+   included, and stores the result in `sha1_hash`.
+3. The unique index ensures MongoDB rejects any insert whose content (per
+   the hash) is already in the collection.
 
-## What's Different  
-In the original plugin, models were deleted with a date reference only. This version takes that and uses a Boolean flag to to mark models deleted/restored. Adds `deletedAt` field to record when a document was deleted. Additionally, it removes a lot of overhead from the original code and doesn't use Coffeescript for the original code.  
+## Usage
 
-## License  
-This plugin is licensed under the MIT license and can ve viewed in the LICENSE file.  
+### Exclude specific fields from the hash
 
-## Installation  
-Install using [npm](https://npmjs.org)  
-```
-npm install mongoose-softdelete --save
-```  
-
-## Tests  
-IMPORTANT: You need to have MongoDB running to run tests  
+```js
+var mongoose     = require('mongoose');
+var no_duplicate = require('elderwand-mongoose-no-duplicate');
+
+var ArticleSchema = new mongoose.Schema({
+    title: String,
+    body: String,
+    createdAt: Date,
+    lastSeenAt: Date,
+    meta: {
+        views: Number,
+        flags: { internal: String }
+    }
+});
 
-```
-npm test
+ArticleSchema.plugin(no_duplicate.getPluginWithOptions({
+    exclude: [
+        'createdAt',
+        'lastSeenAt',
+        'meta.views',
+        'meta.flags.internal'
+    ],
+    sparse: true     // unique index is sparse — only enforced on docs that
+                     // have sha1_hash set (every saved doc, in practice)
+}));
+
+mongoose.model('Article', ArticleSchema);
 ```
 
-## Usage  
+Two articles with identical `title` and `body` will collide on `sha1_hash`
+even if their timestamps and `meta.views` counts differ.
 
-**models/test.js**  
+### Hash only specific fields
 
 ```js
-var mongoose = require('mongoose'),
-    Schema = mongoose.Schema,
-    soft_delete = require('mongoose-softdelete');
+ArticleSchema.plugin(no_duplicate.getPluginWithOptions({
+    includeOnly: ['title', 'body'],
+    sparse: true
+}));
+```
 
-var TestSchema = new Schema({
-  somefield: { type: String, default: 'Hello World!'}
-});
+Only `title` and `body` contribute to the hash; everything else is ignored.
+
+## Plugin options
 
-TestSchema.plugin(soft_delete);
+| Option        | Type      | Default | Notes                                                                  |
+| ------------- | --------- | ------- | ---------------------------------------------------------------------- |
+| `exclude`     | string[]  | `[]`    | Top-level or dotted paths to omit from the hash input.                 |
+| `includeOnly` | string[]  | —       | If set, only these paths contribute to the hash (overrides `exclude`). |
+| `sparse`      | boolean   | `false` | Forwarded to the unique index definition.                              |
+| `dropDups`    | boolean   | `false` | Forwarded to mongoose. **Note:** removed in MongoDB ≥ 3.0; ignored.    |
 
-mongoose.model('Test', TestSchema);  
-```  
+`_id` is always excluded from the hash regardless of `exclude` /
+`includeOnly` — otherwise every document would be unique by definition.
 
-**controllers/test.js**  
+## Catching the duplicate error
 
-```js  
-var Test = mongoose.model('Test');
-var test = new Test();
+When the unique index trips, MongoDB raises an `E11000 duplicate key
+error`. The plugin does not translate or wrap this — callers should check
+for `err.code === 11000`:
 
-test.softdelete(function(err, newTest) {
-  if (err) { callback(err); }  
-  callback(null, newTest);
+```js
+new Article({ title: 'Same', body: 'thing' }).save(function (err, doc) {
+    if (err && err.code === 11000) {
+        return console.log('duplicate; document already exists');
+    }
+    if (err) return handle(err);
+    return console.log('saved:', doc._id);
 });
+```
+
+## Limitations
+
+These are known and documented in the characterization test suite:
 
-test.restore(function(err, newTest) {
-  if (err) { callback(err); }  
-  callback(null, newTest);
-});  
-```  
- 
-Built with love in Dhaka, Bangladesh by [Riyadh Al Nur](https://twitter.com/riyadhalnur)
+- The hash is derived from `JSON.stringify(model.toObject())` — key
+  insertion order matters. Two semantically identical documents whose keys
+  were set in different orders may hash differently. Don't rely on this
+  plugin for cross-system content equivalence.
+- Insert paths that bypass `.save()` (i.e. `Model.insertMany`,
+  `Model.collection.insert(…)`, `findOneAndUpdate({…}, {upsert: true})`)
+  skip the `pre('save')` hook, so the `sha1_hash` field is never populated
+  and duplicates are not blocked on those paths.
+- `dropDups` is forwarded to mongoose for backwards compatibility but is a
+  no-op against MongoDB ≥ 3.0.
+
+## Tests
+
+```
+npm test                   # offline characterization suite
+npm run test:integration   # requires MongoDB at localhost:27017
+```
 
+## License
 
-**Populate**
-I Added function to fix the problem that loading soft deleted objects when populating properties
+MIT.

package/NoDuplicate/no-duplicate.js

@@ -4,47 +4,65 @@ var mongoose = require('mongoose')
     , Query    = mongoose.Query
     , crypto = require("crypto");
 var defaultExclude = ["_id"];
+
+/**
+ * Navigate a dotted path on `obj`, applying `action(token, lastKey)` to
+ * the parent of the final segment. Returns false if the path could not
+ * be fully resolved (i.e. an intermediate key is missing or non-object).
+ *
+ * Fix: the original code dereferenced intermediate path keys without a
+ * guard and crashed with `Cannot read properties of undefined` whenever
+ * a document was missing a key in the middle of a configured nested
+ * exclude/include path. This helper makes that case a no-op.
+ */
+function walkDottedPath(obj, dottedKey, action){
+    if(dottedKey.indexOf(".") === -1){
+        action(obj, dottedKey);
+        return true;
+    }
+    var deep = dottedKey.split(".");
+    var last = deep.pop();
+    var token = obj;
+    for(var j = 0; j < deep.length; j++){
+        token = token != null ? token[deep[j]] : undefined;
+        if(token == null || typeof token !== "object"){
+            return false; // intermediate path missing — nothing to do
+        }
+    }
+    action(token, last);
+    return true;
+}
+
 function hashObject(model, exclude){
-    exclude = exclude.concat(defaultExclude);
+    exclude = (exclude || []).concat(defaultExclude);
     var obj = model.toObject();
 
-    for(var i in exclude){
+    for(var i = 0; i < exclude.length; i++){
         var key = exclude[i];
-        if(key.indexOf(".") != -1){
-            var deep = key.split(".");
-            var last = deep.pop();
-            var token = obj;
-            for(var j in deep){
-                token = token[deep[j]];
-            }
-            token[last] = undefined;
-        }else{
-            obj[key] = undefined;
-        }
+        walkDottedPath(obj, key, function(parent, lastKey){
+            parent[lastKey] = undefined;
+        });
     }
     return crypto.createHash('sha1').update(JSON.stringify(obj)).digest('Base64')
 }
 function hashIncludeOnlyObject(model, include){
     var obj = model.toObject();
     var hashObject = {}
-    for(var i in include){
+    include = include || [];
+    for(var i = 0; i < include.length; i++){
         var key = include[i];
-        if(key.indexOf(".") != -1){
-            var deep = key.split(".");
-            var last = deep.pop();
-            var token = obj;
-            for(var j in deep){
-                token = token[deep[j]];
-            }
-            hashObject[key] = token[last]
-        }else{
-            hashObject[key] = obj[key];
-        }
+        walkDottedPath(obj, key, function(parent, lastKey){
+            hashObject[key] = parent[lastKey];
+        });
     }
     return crypto.createHash('sha1').update(JSON.stringify(hashObject)).digest('Base64')
 }
 module.exports.getPluginWithOptions = function(options){
 
+    // Fix: tolerate `getPluginWithOptions()` and `getPluginWithOptions({})`
+    // rather than crashing on `options.sparse`. exclude/includeOnly fall
+    // back to empty arrays so the pre-save hook can run.
+    options = options || {};
     options.sparse = options.sparse || false;
     options.dropDups = options.dropDups || false;
     return function(schema) {