@bedrockio/model 0.11.2 → 0.12.0

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 0.12.0
+
+- Handle aggregate pipelines in search.
+
+## 0.11.3
+
+- Added warning when id field not passed for unique check.
+
 ## 0.11.2
 
 - Fixed issue with non-async hooks hanging.

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

package/dist/cjs/soft-delete.js

@@ -6,8 +6,10 @@ Object.defineProperty(exports, "__esModule", {
 exports.applySoftDelete = applySoftDelete;
 exports.assertUnique = assertUnique;
 var _lodash = require("lodash");
+var _warn = _interopRequireDefault(require("./warn"));
 var _query = require("./query");
 var _errors = require("./errors");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 function applySoftDelete(schema) {
   applyQueries(schema);
   applyUniqueConstraints(schema);
@@ -32,7 +34,7 @@ async function assertUnique(options) {
   };
   const exists = await model.exists(query);
   if (exists) {
-    const message = getUniqueErrorMessage(model, field);
+    const message = getUniqueErrorMessage(field, options);
     throw new _errors.UniqueConstraintError(message, {
       model,
       field,
@@ -40,7 +42,11 @@ async function assertUnique(options) {
     });
   }
 }
-function getUniqueErrorMessage(model, field) {
+function getUniqueErrorMessage(field, options) {
+  const {
+    id,
+    model
+  } = options;
   const {
     modelName
   } = model;
@@ -48,6 +54,9 @@ function getUniqueErrorMessage(model, field) {
     const name = field === 'phone' ? 'phone number' : field;
     return `A user with that ${name} already exists.`;
   } else {
+    if (!id) {
+      (0, _warn.default)('Note "id" field was not passed to exclude self for unique check.');
+    }
     return `"${field}" already exists.`;
   }
 }

package/package.json

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

package/src/const.js

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

package/src/search.js

@@ -26,51 +26,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 +62,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 +185,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 +203,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

package/src/soft-delete.js

@@ -1,5 +1,7 @@
 import { isEqual } from 'lodash';
 
+import warn from './warn';
+
 import { wrapQuery } from './query';
 import { UniqueConstraintError } from './errors';
 
@@ -24,8 +26,9 @@ export async function assertUnique(options) {
   };
 
   const exists = await model.exists(query);
+
   if (exists) {
-    const message = getUniqueErrorMessage(model, field);
+    const message = getUniqueErrorMessage(field, options);
     throw new UniqueConstraintError(message, {
       model,
       field,
@@ -34,12 +37,16 @@ export async function assertUnique(options) {
   }
 }
 
-function getUniqueErrorMessage(model, field) {
+function getUniqueErrorMessage(field, options) {
+  const { id, model } = options;
   const { modelName } = model;
   if (modelName === 'User' && !field.includes('.')) {
     const name = field === 'phone' ? 'phone number' : field;
     return `A user with that ${name} already exists.`;
   } else {
+    if (!id) {
+      warn('Note "id" field was not passed to exclude self for unique check.');
+    }
     return `"${field}" already exists.`;
   }
 }

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":"AAsBA,gEAaC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eA4CyD,CAAC;;;;;;;;;;;;;;;;;EAnBzD"}

package/types/soft-delete.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"soft-delete.d.ts","sourceRoot":"","sources":["../src/soft-delete.js"],"names":[],"mappings":"AAKA,mDAIC;AAED,0DAuBC"}
+{"version":3,"file":"soft-delete.d.ts","sourceRoot":"","sources":["../src/soft-delete.js"],"names":[],"mappings":"AAOA,mDAIC;AAED,0DAwBC"}