api, login, auth

4 files changed, 292 insertions, 0 deletions

diff --git a/node_modules/mongoose/lib/helpers/document/cleanModifiedSubpaths.js b/node_modules/mongoose/lib/helpers/document/cleanModifiedSubpaths.js
new file mode 100644
index 0000000..252d348
--- /dev/null
+++ b/node_modules/mongoose/lib/helpers/document/cleanModifiedSubpaths.js
@@ -0,0 +1,28 @@
+'use strict';
+
+/*!
+ * ignore
+ */
+
+module.exports = function cleanModifiedSubpaths(doc, path, options) {
+  options = options || {};
+  const skipDocArrays = options.skipDocArrays;
+
+  let deleted = 0;
+  if (!doc) {
+    return deleted;
+  }
+  for (const modifiedPath of Object.keys(doc.$__.activePaths.states.modify)) {
+    if (skipDocArrays) {
+      const schemaType = doc.schema.path(modifiedPath);
+      if (schemaType && schemaType.$isMongooseDocumentArray) {
+        continue;
+      }
+    }
+    if (modifiedPath.startsWith(path + '.')) {
+      delete doc.$__.activePaths.states.modify[modifiedPath];
+      ++deleted;
+    }
+  }
+  return deleted;
+};
diff --git a/node_modules/mongoose/lib/helpers/document/compile.js b/node_modules/mongoose/lib/helpers/document/compile.js
new file mode 100644
index 0000000..def45e6
--- /dev/null
+++ b/node_modules/mongoose/lib/helpers/document/compile.js
@@ -0,0 +1,204 @@
+'use strict';
+
+const documentSchemaSymbol = require('../../helpers/symbols').documentSchemaSymbol;
+const get = require('../../helpers/get');
+const internalToObjectOptions = require('../../options').internalToObjectOptions;
+const utils = require('../../utils');
+
+let Document;
+const getSymbol = require('../../helpers/symbols').getSymbol;
+const scopeSymbol = require('../../helpers/symbols').scopeSymbol;
+
+/*!
+ * exports
+ */
+
+exports.compile = compile;
+exports.defineKey = defineKey;
+
+/*!
+ * Compiles schemas.
+ */
+
+function compile(tree, proto, prefix, options) {
+  Document = Document || require('../../document');
+  const keys = Object.keys(tree);
+  const len = keys.length;
+  let limb;
+  let key;
+
+  for (let i = 0; i < len; ++i) {
+    key = keys[i];
+    limb = tree[key];
+
+    const hasSubprops = utils.isPOJO(limb) && Object.keys(limb).length &&
+      (!limb[options.typeKey] || (options.typeKey === 'type' && limb.type.type));
+    const subprops = hasSubprops ? limb : null;
+
+    defineKey(key, subprops, proto, prefix, keys, options);
+  }
+}
+
+/*!
+ * Defines the accessor named prop on the incoming prototype.
+ */
+
+function defineKey(prop, subprops, prototype, prefix, keys, options) {
+  Document = Document || require('../../document');
+  const path = (prefix ? prefix + '.' : '') + prop;
+  prefix = prefix || '';
+
+  if (subprops) {
+    Object.defineProperty(prototype, prop, {
+      enumerable: true,
+      configurable: true,
+      get: function() {
+        const _this = this;
+        if (!this.$__.getters) {
+          this.$__.getters = {};
+        }
+
+        if (!this.$__.getters[path]) {
+          const nested = Object.create(Document.prototype, getOwnPropertyDescriptors(this));
+
+          // save scope for nested getters/setters
+          if (!prefix) {
+            nested.$__[scopeSymbol] = this;
+          }
+          nested.$__.nestedPath = path;
+
+          Object.defineProperty(nested, 'schema', {
+            enumerable: false,
+            configurable: true,
+            writable: false,
+            value: prototype.schema
+          });
+
+          Object.defineProperty(nested, documentSchemaSymbol, {
+            enumerable: false,
+            configurable: true,
+            writable: false,
+            value: prototype.schema
+          });
+
+          Object.defineProperty(nested, 'toObject', {
+            enumerable: false,
+            configurable: true,
+            writable: false,
+            value: function() {
+              return utils.clone(_this.get(path, null, {
+                virtuals: get(this, 'schema.options.toObject.virtuals', null)
+              }));
+            }
+          });
+
+          Object.defineProperty(nested, '$__get', {
+            enumerable: false,
+            configurable: true,
+            writable: false,
+            value: function() {
+              return _this.get(path, null, {
+                virtuals: get(this, 'schema.options.toObject.virtuals', null)
+              });
+            }
+          });
+
+          Object.defineProperty(nested, 'toJSON', {
+            enumerable: false,
+            configurable: true,
+            writable: false,
+            value: function() {
+              return _this.get(path, null, {
+                virtuals: get(_this, 'schema.options.toJSON.virtuals', null)
+              });
+            }
+          });
+
+          Object.defineProperty(nested, '$__isNested', {
+            enumerable: false,
+            configurable: true,
+            writable: false,
+            value: true
+          });
+
+          const _isEmptyOptions = Object.freeze({
+            minimize: true,
+            virtuals: false,
+            getters: false,
+            transform: false
+          });
+          Object.defineProperty(nested, '$isEmpty', {
+            enumerable: false,
+            configurable: true,
+            writable: false,
+            value: function() {
+              return Object.keys(this.get(path, null, _isEmptyOptions) || {}).length === 0;
+            }
+          });
+
+          Object.defineProperty(nested, '$__parent', {
+            enumerable: false,
+            configurable: true,
+            writable: false,
+            value: this
+          });
+
+          compile(subprops, nested, path, options);
+          this.$__.getters[path] = nested;
+        }
+
+        return this.$__.getters[path];
+      },
+      set: function(v) {
+        if (v != null && v.$__isNested) {
+          // Convert top-level to POJO, but leave subdocs hydrated so `$set`
+          // can handle them. See gh-9293.
+          v = v.$__get();
+        } else if (v instanceof Document && !v.$__isNested) {
+          v = v.toObject(internalToObjectOptions);
+        }
+        const doc = this.$__[scopeSymbol] || this;
+        doc.$set(path, v);
+      }
+    });
+  } else {
+    Object.defineProperty(prototype, prop, {
+      enumerable: true,
+      configurable: true,
+      get: function() {
+        return this[getSymbol].call(this.$__[scopeSymbol] || this, path);
+      },
+      set: function(v) {
+        this.$set.call(this.$__[scopeSymbol] || this, path, v);
+      }
+    });
+  }
+}
+
+// gets descriptors for all properties of `object`
+// makes all properties non-enumerable to match previous behavior to #2211
+function getOwnPropertyDescriptors(object) {
+  const result = {};
+
+  Object.getOwnPropertyNames(object).forEach(function(key) {
+    result[key] = Object.getOwnPropertyDescriptor(object, key);
+    // Assume these are schema paths, ignore them re: #5470
+    if (result[key].get) {
+      delete result[key];
+      return;
+    }
+    result[key].enumerable = [
+      'isNew',
+      '$__',
+      'errors',
+      '_doc',
+      '$locals',
+      '$op',
+      '__parentArray',
+      '__index',
+      '$isDocumentArrayElement'
+    ].indexOf(key) === -1;
+  });
+
+  return result;
+}
diff --git a/node_modules/mongoose/lib/helpers/document/getEmbeddedDiscriminatorPath.js b/node_modules/mongoose/lib/helpers/document/getEmbeddedDiscriminatorPath.js
new file mode 100644
index 0000000..a2784e3
--- /dev/null
+++ b/node_modules/mongoose/lib/helpers/document/getEmbeddedDiscriminatorPath.js
@@ -0,0 +1,43 @@
+'use strict';
+
+const get = require('../get');
+
+/*!
+ * Like `schema.path()`, except with a document, because impossible to
+ * determine path type without knowing the embedded discriminator key.
+ */
+
+module.exports = function getEmbeddedDiscriminatorPath(doc, path, options) {
+  options = options || {};
+  const typeOnly = options.typeOnly;
+  const parts = path.split('.');
+  let schema = null;
+  let type = 'adhocOrUndefined';
+
+  for (let i = 0; i < parts.length; ++i) {
+    const subpath = parts.slice(0, i + 1).join('.');
+    schema = doc.schema.path(subpath);
+    if (schema == null) {
+      type = 'adhocOrUndefined';
+      continue;
+    }
+    if (schema.instance === 'Mixed') {
+      return typeOnly ? 'real' : schema;
+    }
+    type = doc.schema.pathType(subpath);
+    if ((schema.$isSingleNested || schema.$isMongooseDocumentArrayElement) &&
+        schema.schema.discriminators != null) {
+      const discriminators = schema.schema.discriminators;
+      const discriminatorKey = doc.get(subpath + '.' +
+        get(schema, 'schema.options.discriminatorKey'));
+      if (discriminatorKey == null || discriminators[discriminatorKey] == null) {
+        continue;
+      }
+      const rest = parts.slice(i + 1).join('.');
+      return getEmbeddedDiscriminatorPath(doc.get(subpath), rest, options);
+    }
+  }
+
+  // Are we getting the whole schema or just the type, 'real', 'nested', etc.
+  return typeOnly ? type : schema;
+};
diff --git a/node_modules/mongoose/lib/helpers/document/handleSpreadDoc.js b/node_modules/mongoose/lib/helpers/document/handleSpreadDoc.js
new file mode 100644
index 0000000..d3075e4
--- /dev/null
+++ b/node_modules/mongoose/lib/helpers/document/handleSpreadDoc.js
@@ -0,0 +1,17 @@
+'use strict';
+
+const utils = require('../../utils');
+
+/**
+ * Using spread operator on a Mongoose document gives you a
+ * POJO that has a tendency to cause infinite recursion. So
+ * we use this function on `set()` to prevent that.
+ */
+
+module.exports = function handleSpreadDoc(v) {
+  if (utils.isPOJO(v) && v.$__ != null && v._doc != null) {
+    return v._doc;
+  }
+
+  return v;
+};
\ No newline at end of file