@bedrockio/model 0.11.3 → 0.12.1

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 0.12.1
+
+- Allow range-based search on string fields.
+
+## 0.12.0
+
+- Handle aggregate pipelines in search.
+
 ## 0.11.3
 
 - Added warning when id field not passed for unique check.

package/dist/cjs/const.js

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.SEARCH_DEFAULTS = exports.POPULATE_MAX_DEPTH = void 0;
 const SEARCH_DEFAULTS = exports.SEARCH_DEFAULTS = {
+  skip: 0,
   limit: 50,
   sort: {
     field: '_id',

package/dist/cjs/search.js

@@ -25,44 +25,12 @@ function applySearch(schema, definition) {
   const {
     search: config = {}
   } = definition;
-  schema.static('search', function search(body = {}) {
-    const options = mergeOptions(_const.SEARCH_DEFAULTS, config.query, body);
-    const {
-      ids,
-      keyword,
-      skip = 0,
-      limit,
-      sort,
-      ...rest
-    } = options;
-    let query = normalizeQuery(rest, schema.obj);
-    if (ids?.length) {
-      query = {
-        ...query,
-        _id: {
-          $in: ids
-        }
-      };
-    }
-    if (keyword) {
-      const keywordQuery = buildKeywordQuery(schema, keyword, config);
-      query = (0, _query.mergeQuery)(query, keywordQuery);
-    }
-    if (_env.debug) {
-      _logger.default.info(`Search query for ${this.modelName}:\n`, JSON.stringify(query, null, 2));
+  schema.static('search', function search(...args) {
+    if (Array.isArray(args[0])) {
+      return searchPipeline(this, args[0], args[1]);
+    } else {
+      return searchQuery(this, args[0], config);
     }
-    const mQuery = this.find(query).sort(resolveSort(sort, schema)).skip(skip).limit(limit);
-    return (0, _query.wrapQuery)(mQuery, async promise => {
-      const [data, total] = await Promise.all([promise, this.countDocuments(query)]);
-      return {
-        data,
-        meta: {
-          total,
-          skip,
-          limit
-        }
-      };
-    });
   });
 }
 function searchValidation(options = {}) {
@@ -89,6 +57,90 @@ function searchValidation(options = {}) {
     ...appendSchema
   });
 }
+function searchQuery(Model, options, config) {
+  const {
+    schema
+  } = Model;
+  options = mergeOptions(_const.SEARCH_DEFAULTS, options);
+  let {
+    ids,
+    keyword,
+    skip,
+    limit,
+    sort,
+    ...rest
+  } = options;
+  sort = resolveSort(sort, schema);
+  let query = normalizeQuery(rest, schema.obj);
+  if (ids?.length) {
+    query = (0, _query.mergeQuery)(query, {
+      _id: {
+        $in: ids
+      }
+    });
+  }
+  if (keyword) {
+    const keywordQuery = buildKeywordQuery(schema, keyword, config);
+    query = (0, _query.mergeQuery)(query, keywordQuery);
+  }
+  if (_env.debug) {
+    _logger.default.info(`Search query for ${Model.modelName}:\n`, JSON.stringify(query, null, 2));
+  }
+  const mQuery = Model.find(query).sort(sort).skip(skip).limit(limit);
+  return (0, _query.wrapQuery)(mQuery, async promise => {
+    const [data, total] = await Promise.all([promise, Model.countDocuments(query)]);
+    return {
+      data,
+      meta: {
+        total,
+        skip,
+        limit
+      }
+    };
+  });
+}
+function searchPipeline(Model, pipeline, options) {
+  const {
+    schema
+  } = Model;
+  options = mergeOptions(_const.SEARCH_DEFAULTS, options);
+  let {
+    skip,
+    limit,
+    sort
+  } = options;
+  sort = resolveSort(sort, schema);
+  if (_env.debug) {
+    _logger.default.info(`Search pipeline for ${Model.modelName}:\n`, JSON.stringify(pipeline, null, 2));
+  }
+  const aggregate = Model.aggregate([...pipeline, {
+    $facet: {
+      data: [{
+        $sort: sort
+      }, {
+        $skip: skip
+      }, {
+        $limit: limit
+      }],
+      meta: [{
+        $count: 'total'
+      }]
+    }
+  }]);
+  return (0, _query.wrapQuery)(aggregate, async promise => {
+    const result = await promise;
+    const data = result[0].data;
+    const total = result[0].meta[0]?.total ?? 0;
+    return {
+      data,
+      meta: {
+        skip,
+        limit,
+        total
+      }
+    };
+  });
+}
 function getSortSchema(sort) {
   const schema = _yada.default.object({
     field: _yada.default.string().required(),
@@ -104,13 +156,18 @@ function validateDefinition(definition) {
 }
 function resolveSort(sort, schema) {
   if (!sort) {
-    sort = [];
-  } else if (!Array.isArray(sort)) {
+    return {
+      _id: 1
+    };
+  }
+  const result = {};
+  if (!Array.isArray(sort)) {
     sort = [sort];
   }
   for (let {
     name,
-    field
+    field,
+    order
   } of sort) {
     if (name) {
       throw new Error('Sort property "name" is not allowed. Use "field" instead.');
@@ -118,13 +175,9 @@ function resolveSort(sort, schema) {
     if (!field.startsWith('$') && !schema.path(field)) {
       throw new Error(`Unknown sort field "${field}".`);
     }
+    result[field] = order === 'desc' ? -1 : 1;
   }
-  return sort.map(({
-    field,
-    order
-  }) => {
-    return [field, order === 'desc' ? -1 : 1];
-  });
+  return result;
 }
 
 // Keyword queries
@@ -307,11 +360,12 @@ function isEmptyArrayQuery(schema, key, value) {
   return !isMongoOperator(key) && (0, _utils.isArrayField)(schema, key) && value === null;
 }
 function isRangeQuery(schema, key, value) {
-  // Range queries only allowed on Date and Number fields.
-  if (!(0, _utils.isDateField)(schema, key) && !(0, _utils.isNumberField)(schema, key)) {
+  if (!(0, _lodash.isPlainObject)(value)) {
     return false;
   }
-  return typeof value === 'object' && !!value;
+
+  // Range queries allowed on Date, Number, and String fields.
+  return (0, _utils.isDateField)(schema, key) || (0, _utils.isNumberField)(schema, key) || (0, _utils.isStringField)(schema, key);
 }
 function mapOperatorQuery(obj) {
   const query = {};

package/dist/cjs/utils.js

@@ -12,6 +12,7 @@ exports.isMongooseSchema = isMongooseSchema;
 exports.isNumberField = isNumberField;
 exports.isReferenceField = isReferenceField;
 exports.isSchemaTypedef = isSchemaTypedef;
+exports.isStringField = isStringField;
 exports.resolveRefPath = resolveRefPath;
 var _mongoose = _interopRequireDefault(require("mongoose"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
@@ -50,6 +51,9 @@ function isDateField(obj, path) {
 function isNumberField(obj, path) {
   return isType(obj, path, 'Number');
 }
+function isStringField(obj, path) {
+  return isType(obj, path, 'String');
+}
 function isArrayField(obj, path) {
   const field = getField(obj, path);
   return Array.isArray(field?.type);

package/dist/cjs/validation.js

@@ -23,7 +23,7 @@ const DATE_TAGS = {
   'x-schema': 'DateTime',
   'x-description': 'A `string` in [ISO 8601](https://www.iso.org/iso-8601-date-and-time-format.html) format.'
 };
-const OBJECT_ID_SCHEMA = exports.OBJECT_ID_SCHEMA = _yada.default.string().mongo().message('Must be an id.').tag({
+const OBJECT_ID_SCHEMA = exports.OBJECT_ID_SCHEMA = _yada.default.string().mongo().message('Must be a valid object id.').tag({
   'x-schema': 'ObjectId',
   'x-description': 'A 24 character hexadecimal string representing a Mongo [ObjectId](https://bit.ly/3YPtGlU).'
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bedrockio/model",
-  "version": "0.11.3",
+  "version": "0.12.1",
   "description": "Bedrock utilities for model creation.",
   "type": "module",
   "scripts": {
@@ -39,7 +39,7 @@
     "@babel/preset-env": "^7.26.0",
     "@bedrockio/eslint-plugin": "^1.1.7",
     "@bedrockio/prettier-config": "^1.0.2",
-    "@bedrockio/yada": "^1.4.1",
+    "@bedrockio/yada": "^1.4.2",
     "@shelf/jest-mongodb": "^5.1.0",
     "eslint": "^9.19.0",
     "jest": "^29.7.0",

package/src/const.js

@@ -1,4 +1,5 @@
 export const SEARCH_DEFAULTS = {
+  skip: 0,
   limit: 50,
   sort: {
     field: '_id',

package/src/search.js

@@ -8,6 +8,7 @@ import {
   isArrayField,
   isDateField,
   isNumberField,
+  isStringField,
   resolveRefPath,
 } from './utils';
 
@@ -26,51 +27,12 @@ export function applySearch(schema, definition) {
 
   const { search: config = {} } = definition;
 
-  schema.static('search', function search(body = {}) {
-    const options = mergeOptions(SEARCH_DEFAULTS, config.query, body);
-
-    const { ids, keyword, skip = 0, limit, sort, ...rest } = options;
-
-    let query = normalizeQuery(rest, schema.obj);
-
-    if (ids?.length) {
-      query = {
-        ...query,
-        _id: { $in: ids },
-      };
-    }
-
-    if (keyword) {
-      const keywordQuery = buildKeywordQuery(schema, keyword, config);
-      query = mergeQuery(query, keywordQuery);
-    }
-
-    if (debug) {
-      logger.info(
-        `Search query for ${this.modelName}:\n`,
-        JSON.stringify(query, null, 2),
-      );
+  schema.static('search', function search(...args) {
+    if (Array.isArray(args[0])) {
+      return searchPipeline(this, args[0], args[1]);
+    } else {
+      return searchQuery(this, args[0], config);
     }
-
-    const mQuery = this.find(query)
-      .sort(resolveSort(sort, schema))
-      .skip(skip)
-      .limit(limit);
-
-    return wrapQuery(mQuery, async (promise) => {
-      const [data, total] = await Promise.all([
-        promise,
-        this.countDocuments(query),
-      ]);
-      return {
-        data,
-        meta: {
-          total,
-          skip,
-          limit,
-        },
-      };
-    });
   });
 }
 
@@ -101,6 +63,105 @@ export function searchValidation(options = {}) {
   });
 }
 
+function searchQuery(Model, options, config) {
+  const { schema } = Model;
+
+  options = mergeOptions(SEARCH_DEFAULTS, options);
+  let { ids, keyword, skip, limit, sort, ...rest } = options;
+
+  sort = resolveSort(sort, schema);
+
+  let query = normalizeQuery(rest, schema.obj);
+
+  if (ids?.length) {
+    query = mergeQuery(query, {
+      _id: { $in: ids },
+    });
+  }
+
+  if (keyword) {
+    const keywordQuery = buildKeywordQuery(schema, keyword, config);
+    query = mergeQuery(query, keywordQuery);
+  }
+
+  if (debug) {
+    logger.info(
+      `Search query for ${Model.modelName}:\n`,
+      JSON.stringify(query, null, 2),
+    );
+  }
+
+  const mQuery = Model.find(query).sort(sort).skip(skip).limit(limit);
+
+  return wrapQuery(mQuery, async (promise) => {
+    const [data, total] = await Promise.all([
+      promise,
+      Model.countDocuments(query),
+    ]);
+    return {
+      data,
+      meta: {
+        total,
+        skip,
+        limit,
+      },
+    };
+  });
+}
+
+function searchPipeline(Model, pipeline, options) {
+  const { schema } = Model;
+  options = mergeOptions(SEARCH_DEFAULTS, options);
+
+  let { skip, limit, sort } = options;
+  sort = resolveSort(sort, schema);
+
+  if (debug) {
+    logger.info(
+      `Search pipeline for ${Model.modelName}:\n`,
+      JSON.stringify(pipeline, null, 2),
+    );
+  }
+
+  const aggregate = Model.aggregate([
+    ...pipeline,
+    {
+      $facet: {
+        data: [
+          {
+            $sort: sort,
+          },
+          {
+            $skip: skip,
+          },
+          {
+            $limit: limit,
+          },
+        ],
+        meta: [
+          {
+            $count: 'total',
+          },
+        ],
+      },
+    },
+  ]);
+
+  return wrapQuery(aggregate, async (promise) => {
+    const result = await promise;
+    const data = result[0].data;
+    const total = result[0].meta[0]?.total ?? 0;
+    return {
+      data,
+      meta: {
+        skip,
+        limit,
+        total,
+      },
+    };
+  });
+}
+
 function getSortSchema(sort) {
   const schema = yd
     .object({
@@ -125,11 +186,16 @@ function validateDefinition(definition) {
 
 function resolveSort(sort, schema) {
   if (!sort) {
-    sort = [];
-  } else if (!Array.isArray(sort)) {
+    return { _id: 1 };
+  }
+
+  const result = {};
+
+  if (!Array.isArray(sort)) {
     sort = [sort];
   }
-  for (let { name, field } of sort) {
+
+  for (let { name, field, order } of sort) {
     if (name) {
       throw new Error(
         'Sort property "name" is not allowed. Use "field" instead.',
@@ -138,10 +204,10 @@ function resolveSort(sort, schema) {
     if (!field.startsWith('$') && !schema.path(field)) {
       throw new Error(`Unknown sort field "${field}".`);
     }
+
+    result[field] = order === 'desc' ? -1 : 1;
   }
-  return sort.map(({ field, order }) => {
-    return [field, order === 'desc' ? -1 : 1];
-  });
+  return result;
 }
 
 // Keyword queries
@@ -342,11 +408,16 @@ function isEmptyArrayQuery(schema, key, value) {
 }
 
 function isRangeQuery(schema, key, value) {
-  // Range queries only allowed on Date and Number fields.
-  if (!isDateField(schema, key) && !isNumberField(schema, key)) {
+  if (!isPlainObject(value)) {
     return false;
   }
-  return typeof value === 'object' && !!value;
+
+  // Range queries allowed on Date, Number, and String fields.
+  return (
+    isDateField(schema, key) ||
+    isNumberField(schema, key) ||
+    isStringField(schema, key)
+  );
 }
 
 function mapOperatorQuery(obj) {

package/src/utils.js

@@ -38,6 +38,10 @@ export function isNumberField(obj, path) {
   return isType(obj, path, 'Number');
 }
 
+export function isStringField(obj, path) {
+  return isType(obj, path, 'String');
+}
+
 export function isArrayField(obj, path) {
   const field = getField(obj, path);
   return Array.isArray(field?.type);

package/src/validation.js

@@ -19,7 +19,7 @@ const DATE_TAGS = {
 export const OBJECT_ID_SCHEMA = yd
   .string()
   .mongo()
-  .message('Must be an id.')
+  .message('Must be a valid object id.')
   .tag({
     'x-schema': 'ObjectId',
     'x-description':

package/types/const.d.ts

@@ -1,4 +1,5 @@
 export namespace SEARCH_DEFAULTS {
+    let skip: number;
     let limit: number;
     namespace sort {
         let field: string;

package/types/const.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"const.d.ts","sourceRoot":"","sources":["../src/const.js"],"names":[],"mappings":";;;;;;;AAQA,iCAAkC,CAAC,CAAC"}
+{"version":3,"file":"const.d.ts","sourceRoot":"","sources":["../src/const.js"],"names":[],"mappings":";;;;;;;;AASA,iCAAkC,CAAC,CAAC"}

package/types/search.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../src/search.js"],"names":[],"mappings":"AAsBA,gEAoDC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAYa,CAAC;;;;;;;;;;;;;;;;;EAab"}
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../src/search.js"],"names":[],"mappings":"AAuBA,gEAaC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eA4CwC,CAAC;;;;;;;;;;;;;;;;;EAnBxC"}

package/types/utils.d.ts

@@ -3,6 +3,7 @@ export function isMongooseSchema(obj: any): obj is mongoose.Schema<any, any, any
 export function isReferenceField(obj: any, path: any): boolean;
 export function isDateField(obj: any, path: any): boolean;
 export function isNumberField(obj: any, path: any): boolean;
+export function isStringField(obj: any, path: any): boolean;
 export function isArrayField(obj: any, path: any): boolean;
 export function isSchemaTypedef(arg: any): boolean;
 export function getField(obj: any, path: any): any;

package/types/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.js"],"names":[],"mappings":"AAQA,iDAcC;AAED,gHAEC;AAED,+DAEC;AAED,0DAEC;AAED,4DAEC;AAED,2DAGC;AAOD,mDAGC;AAuBD,mDAYC;AAKD;;;;EAoBC;AAKD,wDAEC;qBAxHoB,UAAU"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.js"],"names":[],"mappings":"AAQA,iDAcC;AAED,gHAEC;AAED,+DAEC;AAED,0DAEC;AAED,4DAEC;AAED,4DAEC;AAED,2DAGC;AAOD,mDAGC;AAuBD,mDAYC;AAKD;;;;EAoBC;AAKD,wDAEC;qBA5HoB,UAAU"}

package/types/validation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.js"],"names":[],"mappings":"AAoFA,kDAEC;AAED,oEAkFC;AAsBD,wEAoBC;AAgWD;;;EAEC;AAED;;;EAOC;AA7iBD;;;;;;;;;;;;;;;;eAwBoB,CAAC;;;;;;;;;;;;iBAenB,CAAA;kBAEA,CAAF;kBAA4B,CAAC;oBACA,CAAC;oBAE5B,CAAC;;;wBAkBc,CAAC;8BAIjB,CAAC;oBAA+B,CAAC;oBACV,CAAC;oCAGG,CAAC;uBACpB,CAAC;8BAEH,CAAC;uBAAmC,CAAA;iBACrB,CAAC;;;mBAkBX,CAAC;yBAAoC,CAAC;0BACpB,CAAC;yBAEvB,CAAN;sBACW,CAAC;yBAEN,CAAJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eA9CC,CAAC;;;;;;;;;;;;;;;;;;EA5CD"}
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.js"],"names":[],"mappings":"AAoFA,kDAEC;AAED,oEAkFC;AAsBD,wEAoBC;AAgWD;;;EAEC;AAED;;;EAOC;AA7iBD;;;;;;;;;;;;;;;;eAwBQ,CAAC;;;;;;;;;;;;iBAcmC,CAAC;kBAC3B,CAAC;kBAEH,CAAC;oBACA,CAAC;oBACF,CAAC;;;wBAmBZ,CAAC;8BACe,CAAC;oBAGD,CAAC;oBACV,CAAC;oCAGG,CAAC;uBAAmC,CAAA;8BAE9B,CAAC;uBACO,CAAC;iBACrB,CAAC;;;mBAkBL,CAAL;yBAAoC,CAAC;0BACpB,CAAC;yBACT,CAAC;sBAEH,CAAN;yBACc,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eA9CQ,CAAC;;;;;;;;;;;;;;;;;;EA3CrB"}