@bedrockio/model 0.1.12 → 0.1.14

package/dist/cjs/env.js

@@ -0,0 +1,8 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.debug = void 0;
+const debug = !!process.env.DEBUG;
+exports.debug = debug;

package/dist/cjs/search.js

@@ -6,11 +6,13 @@ Object.defineProperty(exports, "__esModule", {
 exports.applySearch = applySearch;
 exports.searchValidation = searchValidation;
 var _yada = _interopRequireDefault(require("@bedrockio/yada"));
+var _logger = _interopRequireDefault(require("@bedrockio/logger"));
 var _mongoose = _interopRequireDefault(require("mongoose"));
 var _lodash = require("lodash");
 var _utils = require("./utils");
 var _const = require("./const");
 var _validation = require("./validation");
+var _env = require("./env");
 var _warn = _interopRequireDefault(require("./warn"));
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 const {
@@ -40,9 +42,12 @@ function applySearch(schema, definition) {
       };
     }
     if (keyword) {
-      Object.assign(query, buildKeywordQuery(keyword, fields));
+      Object.assign(query, buildKeywordQuery(schema, keyword, fields));
     }
     Object.assign(query, normalizeQuery(rest, schema.obj));
+    if (_env.debug) {
+      _logger.default.info(`Search query for ${this.modelName}:\n`, JSON.stringify(query, null, 2));
+    }
     const mQuery = this.find(query).sort(resolveSort(sort, schema)).skip(skip).limit(limit);
 
     // The following construct is awkward but it allows the mongoose query
@@ -158,15 +163,29 @@ function resolveSort(sort, schema) {
 // https://stackoverflow.com/questions/44833817/mongodb-full-and-partial-text-search
 // https://jira.mongodb.org/browse/SERVER-15090
 
-function buildKeywordQuery(keyword, fields) {
+function buildKeywordQuery(schema, keyword, fields) {
+  let queries;
+
+  // Prefer defined search fields over
+  // text indexes to perform keyword search.
   if (fields) {
-    return buildRegexQuery(keyword, fields);
+    queries = buildRegexQuery(keyword, fields);
+  } else if (hasTextIndex(schema)) {
+    queries = [getTextQuery(keyword)];
   } else {
-    return buildTextIndexQuery(keyword);
+    queries = [];
+  }
+  if (ObjectId.isValid(keyword)) {
+    queries.push({
+      _id: keyword
+    });
   }
+  return {
+    $or: queries
+  };
 }
 function buildRegexQuery(keyword, fields) {
-  const queries = fields.map(field => {
+  return fields.map(field => {
     const regexKeyword = keyword.replace(/\+/g, '\\+');
     return {
       [field]: {
@@ -175,34 +194,21 @@ function buildRegexQuery(keyword, fields) {
       }
     };
   });
-  if (ObjectId.isValid(keyword)) {
-    queries.push({
-      _id: keyword
+}
+function hasTextIndex(schema) {
+  return schema.indexes().some(([spec]) => {
+    return Object.values(spec).some(type => {
+      return type === 'text';
     });
-  }
+  });
+}
+function getTextQuery(keyword) {
   return {
-    $or: queries
+    $text: {
+      $search: keyword
+    }
   };
 }
-function buildTextIndexQuery(keyword) {
-  if (ObjectId.isValid(keyword)) {
-    return {
-      $or: [{
-        $text: {
-          $search: keyword
-        }
-      }, {
-        _id: keyword
-      }]
-    };
-  } else {
-    return {
-      $text: {
-        $search: keyword
-      }
-    };
-  }
-}
 
 // Normalizes mongo queries. Flattens plain nested paths
 // to dot syntax while preserving mongo operators and
@@ -257,7 +263,11 @@ function isRangeQuery(schema, key, value) {
 function mapOperatorQuery(obj) {
   const query = {};
   for (let [key, val] of Object.entries(obj)) {
-    query[`$${key}`] = val;
+    if (isMongoOperator(key)) {
+      query[key] = val;
+    } else {
+      query[`$${key}`] = val;
+    }
   }
   return query;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bedrockio/model",
-  "version": "0.1.12",
+  "version": "0.1.14",
   "description": "Bedrock utilities for model creation.",
   "type": "module",
   "scripts": {

package/src/env.js

@@ -0,0 +1 @@
+export const debug = !!process.env.DEBUG;

package/src/search.js

@@ -1,10 +1,12 @@
 import yd from '@bedrockio/yada';
+import logger from '@bedrockio/logger';
 import mongoose from 'mongoose';
 import { pick, isEmpty, isPlainObject } from 'lodash';
 
 import { isDateField, isNumberField, resolveField } from './utils';
 import { SEARCH_DEFAULTS } from './const';
 import { OBJECT_ID_SCHEMA } from './validation';
+import { debug } from './env';
 
 import warn from './warn';
 
@@ -29,11 +31,18 @@ export function applySearch(schema, definition) {
     }
 
     if (keyword) {
-      Object.assign(query, buildKeywordQuery(keyword, fields));
+      Object.assign(query, buildKeywordQuery(schema, keyword, fields));
     }
 
     Object.assign(query, normalizeQuery(rest, schema.obj));
 
+    if (debug) {
+      logger.info(
+        `Search query for ${this.modelName}:\n`,
+        JSON.stringify(query, null, 2)
+      );
+    }
+
     const mQuery = this.find(query)
       .sort(resolveSort(sort, schema))
       .skip(skip)
@@ -165,16 +174,28 @@ function resolveSort(sort, schema) {
 // https://stackoverflow.com/questions/44833817/mongodb-full-and-partial-text-search
 // https://jira.mongodb.org/browse/SERVER-15090
 
-function buildKeywordQuery(keyword, fields) {
+function buildKeywordQuery(schema, keyword, fields) {
+  let queries;
+
+  // Prefer defined search fields over
+  // text indexes to perform keyword search.
   if (fields) {
-    return buildRegexQuery(keyword, fields);
+    queries = buildRegexQuery(keyword, fields);
+  } else if (hasTextIndex(schema)) {
+    queries = [getTextQuery(keyword)];
   } else {
-    return buildTextIndexQuery(keyword);
+    queries = [];
+  }
+
+  if (ObjectId.isValid(keyword)) {
+    queries.push({ _id: keyword });
   }
+
+  return { $or: queries };
 }
 
 function buildRegexQuery(keyword, fields) {
-  const queries = fields.map((field) => {
+  return fields.map((field) => {
     const regexKeyword = keyword.replace(/\+/g, '\\+');
     return {
       [field]: {
@@ -183,24 +204,22 @@ function buildRegexQuery(keyword, fields) {
       },
     };
   });
-  if (ObjectId.isValid(keyword)) {
-    queries.push({ _id: keyword });
-  }
-  return { $or: queries };
 }
 
-function buildTextIndexQuery(keyword) {
-  if (ObjectId.isValid(keyword)) {
-    return {
-      $or: [{ $text: { $search: keyword } }, { _id: keyword }],
-    };
-  } else {
-    return {
-      $text: {
-        $search: keyword,
-      },
-    };
-  }
+function hasTextIndex(schema) {
+  return schema.indexes().some(([spec]) => {
+    return Object.values(spec).some((type) => {
+      return type === 'text';
+    });
+  });
+}
+
+function getTextQuery(keyword) {
+  return {
+    $text: {
+      $search: keyword,
+    },
+  };
 }
 
 // Normalizes mongo queries. Flattens plain nested paths
@@ -257,7 +276,11 @@ function isRangeQuery(schema, key, value) {
 function mapOperatorQuery(obj) {
   const query = {};
   for (let [key, val] of Object.entries(obj)) {
-    query[`$${key}`] = val;
+    if (isMongoOperator(key)) {
+      query[key] = val;
+    } else {
+      query[`$${key}`] = val;
+    }
   }
   return query;
 }

package/types/env.d.ts

@@ -0,0 +1,2 @@
+export const debug: boolean;
+//# sourceMappingURL=env.d.ts.map

package/types/env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../src/env.js"],"names":[],"mappings":"AAAA,4BAAyC"}

package/types/search.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../src/search.js"],"names":[],"mappings":"AAYA,gEAyDC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyBC"}
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../src/search.js"],"names":[],"mappings":"AAcA,gEAgEC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyBC"}