Merge pull request #14350 from Automattic/vkarpov15/helpers-refactor

refactor: make query helpers more consistently fit our loose definition of helpers

lib/aggregate.js

@@ -1019,8 +1019,8 @@ Aggregate.prototype.exec = async function exec() {
   const model = this._model;
   const collection = this._model.collection;
 
-  applyGlobalMaxTimeMS(this.options, model);
-  applyGlobalDiskUse(this.options, model);
+  applyGlobalMaxTimeMS(this.options, model.db.options, model.base.options);
+  applyGlobalDiskUse(this.options, model.db.options, model.base.options);
 
   if (this.options && this.options.cursor) {
     return new AggregationCursor(this);

lib/constants.js

@@ -0,0 +1,36 @@
+'use strict';
+
+/*!
+ * ignore
+ */
+
+const queryOperations = Object.freeze([
+  // Read
+  'countDocuments',
+  'distinct',
+  'estimatedDocumentCount',
+  'find',
+  'findOne',
+  // Update
+  'findOneAndReplace',
+  'findOneAndUpdate',
+  'replaceOne',
+  'updateMany',
+  'updateOne',
+  // Delete
+  'deleteMany',
+  'deleteOne',
+  'findOneAndDelete'
+]);
+
+exports.queryOperations = queryOperations;
+
+/*!
+ * ignore
+ */
+
+const queryMiddlewareFunctions = queryOperations.concat([
+  'validate'
+]);
+
+exports.queryMiddlewareFunctions = queryMiddlewareFunctions;

lib/helpers/model/applyStaticHooks.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const middlewareFunctions = require('../query/applyQueryMiddleware').middlewareFunctions;
+const middlewareFunctions = require('../../constants').queryMiddlewareFunctions;
 const promiseOrCallback = require('../promiseOrCallback');
 
 module.exports = function applyStaticHooks(model, hooks, statics) {

lib/helpers/query/applyGlobalOption.js

@@ -2,12 +2,12 @@
 
 const utils = require('../../utils');
 
-function applyGlobalMaxTimeMS(options, model) {
-  applyGlobalOption(options, model, 'maxTimeMS');
+function applyGlobalMaxTimeMS(options, connectionOptions, baseOptions) {
+  applyGlobalOption(options, connectionOptions, baseOptions, 'maxTimeMS');
 }
 
-function applyGlobalDiskUse(options, model) {
-  applyGlobalOption(options, model, 'allowDiskUse');
+function applyGlobalDiskUse(options, connectionOptions, baseOptions) {
+  applyGlobalOption(options, connectionOptions, baseOptions, 'allowDiskUse');
 }
 
 module.exports = {
@@ -16,14 +16,14 @@ module.exports = {
 };
 
 
-function applyGlobalOption(options, model, optionName) {
+function applyGlobalOption(options, connectionOptions, baseOptions, optionName) {
   if (utils.hasUserDefinedProperty(options, optionName)) {
     return;
   }
 
-  if (utils.hasUserDefinedProperty(model.db.options, optionName)) {
-    options[optionName] = model.db.options[optionName];
-  } else if (utils.hasUserDefinedProperty(model.base.options, optionName)) {
-    options[optionName] = model.base.options[optionName];
+  if (utils.hasUserDefinedProperty(connectionOptions, optionName)) {
+    options[optionName] = connectionOptions[optionName];
+  } else if (utils.hasUserDefinedProperty(baseOptions, optionName)) {
+    options[optionName] = baseOptions[optionName];
   }
 }

lib/helpers/query/castFilterPath.js

@@ -2,8 +2,7 @@
 
 const isOperator = require('./isOperator');
 
-module.exports = function castFilterPath(query, schematype, val) {
-  const ctx = query;
+module.exports = function castFilterPath(ctx, schematype, val) {
   const any$conditionals = Object.keys(val).some(isOperator);
 
   if (!any$conditionals) {

lib/helpers/query/validOps.js

@@ -1,20 +1,3 @@
 'use strict';
 
-module.exports = Object.freeze([
-  // Read
-  'countDocuments',
-  'distinct',
-  'estimatedDocumentCount',
-  'find',
-  'findOne',
-  // Update
-  'findOneAndReplace',
-  'findOneAndUpdate',
-  'replaceOne',
-  'updateMany',
-  'updateOne',
-  // Delete
-  'deleteMany',
-  'deleteOne',
-  'findOneAndDelete'
-]);
+module.exports = require('../../constants').queryMiddlewareFunctions;

lib/model.js

@@ -23,7 +23,6 @@ const VersionError = require('./error/version');
 const ParallelSaveError = require('./error/parallelSave');
 const applyDefaultsHelper = require('./helpers/document/applyDefaults');
 const applyDefaultsToPOJO = require('./helpers/model/applyDefaultsToPOJO');
-const applyQueryMiddleware = require('./helpers/query/applyQueryMiddleware');
 const applyHooks = require('./helpers/model/applyHooks');
 const applyMethods = require('./helpers/model/applyMethods');
 const applyProjection = require('./helpers/projection/applyProjection');
@@ -4841,7 +4840,7 @@ Model.compile = function compile(name, schema, collectionName, connection, base)
   Object.setPrototypeOf(model.Query.prototype, Query.prototype);
   model.Query.base = Query.base;
   model.Query.prototype.constructor = Query;
-  applyQueryMiddleware(model.Query, model);
+  model._applyQueryMiddleware();
   applyQueryMethods(model, schema.query);
 
   return model;
@@ -4979,6 +4978,41 @@ if (util.inspect.custom) {
   Model[util.inspect.custom] = Model.inspect;
 }
 
+/*!
+ * Applies query middleware from this model's schema to this model's
+ * Query constructor.
+ */
+
+Model._applyQueryMiddleware = function _applyQueryMiddleware() {
+  const Query = this.Query;
+  const queryMiddleware = this.schema.s.hooks.filter(hook => {
+    const contexts = _getContexts(hook);
+    if (hook.name === 'validate') {
+      return !!contexts.query;
+    }
+    if (hook.name === 'deleteOne' || hook.name === 'updateOne') {
+      return !!contexts.query || Object.keys(contexts).length === 0;
+    }
+    if (hook.query != null || hook.document != null) {
+      return !!hook.query;
+    }
+    return true;
+  });
+
+  Query.prototype._queryMiddleware = queryMiddleware;
+};
+
+function _getContexts(hook) {
+  const ret = {};
+  if (hook.hasOwnProperty('query')) {
+    ret.query = hook.query;
+  }
+  if (hook.hasOwnProperty('document')) {
+    ret.document = hook.document;
+  }
+  return ret;
+}
+
 /*!
  * Module exports.
  */