@bedrockio/model 0.5.1 → 0.5.2

package/README.md

@@ -21,6 +21,7 @@ Bedrock utilities for model creation.
   - [Assign](#assign)
   - [Slugs](#slugs)
 - [Testing](#testing)
+- [Troubleshooting](#troubleshooting)
 
 ## Install
 
@@ -629,47 +630,29 @@ cache foreign fields on the model to allow filtering on them.
   },
   "search": {
     "cache": {
-      "cachedUserName": {
+      "userName": {
         "type": "String",
         "path": "user.name"
       }
     },
-    "fields": ["cachedUserName"]
+    "fields": ["userName"]
   }
 }
 ```
 
-The above example is equivalent to creating a field called `cachedUserName` and
+The above example is equivalent to creating a field called `userName` and
 updating it when a document is saved:
 
 ```js
 schema.add({
-  cachedUserName: 'String',
+  userName: 'String',
 });
 schema.pre('save', function () {
   await this.populate('user');
-  this.cachedUserName = this.user.name;
+  this.userName = this.user.name;
 });
 ```
 
-Specifying a foreign path in `fields` serves as a shortcut to manually defining
-the cached fields:
-
-```json
-// Equivalent to the above example.
-{
-  "attributes": {
-    "user": {
-      "type": "ObjectId",
-      "ref": "User"
-    }
-  },
-  "search": {
-    "fields": ["user.name"]
-  }
-}
-```
-
 ##### Syncing Search Fields
 
 When first applying or making changes to defined cached search fields, existing
@@ -704,12 +687,13 @@ Cached fields can be made lazy:
   },
   "search": {
     "cache": {
-      "cachedUserName": {
-        "lazy": true,
-        "path": "user.name"
+      "userName": {
+        "type": "String",
+        "path": "user.name",
+        "lazy": true
       }
     },
-    "fields": ["user.name"]
+    "fields": ["userName"]
   }
 }
 ```
@@ -875,7 +859,7 @@ Example 2:
 await Product.findById(id).include('shop.^user.name').
 ```
 
-```json
+```jsonc
 {
   "name": "Product Name",
   "cost": 10,
@@ -897,7 +881,7 @@ Example 3:
 await Product.findById(id).include('shop.user.^name').
 ```
 
-```json
+```jsonc
 {
   "name": "Product Name",
   "cost": 10,
@@ -944,7 +928,7 @@ Example 1: Single wildcard
 const user = await User.findById(id).include('*Name');
 ```
 
-```json
+```jsonc
 {
   "firstName": "Frank",
   "lastName": "Reynolds"
@@ -1381,7 +1365,7 @@ for (let shop of shops) {
 
 Operations may filter on additional fields with `query`:
 
-```json
+```jsonc
 // user.json
 {
   "onDelete": {
@@ -1421,7 +1405,7 @@ operators have special behavior with multiple paths (see note below).
 An operation that specified an array of `paths` will implicitly run an `$or`
 query:
 
-```json
+```jsonc
 // user.json
 {
   "onDelete": {
@@ -1558,3 +1542,19 @@ const Post = createTestModel('Post', {
 ```
 
 Make sure in this case that the model name is unique.
+
+## Troubleshooting
+
+Q: I'm seeing `scopes were requested but not provided` messages everywhere. What
+is this?
+
+A: When a model has fields with `readAccess`, documents require extra context to
+be able to serialize properly. In practice this means calling `toObject` on the
+document without the `scopes` option will generate this warning. This also means
+that functions like `console.log` that internally call `toString` on the
+document will also show warnings. Possible causes include:
+
+- `console.log(document)` - solution here is to remove the log or use the
+  `serializeDocument` helper in bedrock core.
+- A bug in Mongoose (observed in v8.3.2) prevents serialize options from being
+  passed down to nested documents. Bumping the Mongoose version should fix this.

package/dist/cjs/search.js

@@ -24,6 +24,7 @@ const {
 } = _mongoose.default.Types;
 function applySearch(schema, definition) {
   validateDefinition(definition);
+  validateSearchFields(schema, definition);
   applySearchCache(schema, definition);
   const {
     query: searchQuery,
@@ -299,7 +300,6 @@ function parseRegexQuery(str) {
 // Search field caching
 
 function applySearchCache(schema, definition) {
-  normalizeCacheFields(schema, definition);
   if (!definition.search?.cache) {
     return;
   }
@@ -320,15 +320,8 @@ function applySearchCache(schema, definition) {
     }
     const query = {};
     if (!force) {
-      const $or = Object.entries(cache).map(entry => {
-        const [cachedField, def] = entry;
-        const {
-          base
-        } = def;
+      const $or = Object.keys(cache).map(cachedField => {
         return {
-          [base]: {
-            $exists: true
-          },
           [cachedField]: {
             $exists: false
           }
@@ -352,32 +345,18 @@ function applySearchCache(schema, definition) {
     return await this.bulkWrite(ops);
   });
 }
-function normalizeCacheFields(schema, definition) {
+function validateSearchFields(schema, definition) {
   const {
-    fields,
-    cache = {}
+    fields
   } = definition.search || {};
   if (!fields) {
     return;
   }
-  const normalized = [];
   for (let path of fields) {
     if (isForeignField(schema, path)) {
-      const cacheName = generateCacheFieldName(path);
-      const type = resolveSchemaType(schema, path);
-      const base = getRefBase(schema, path);
-      cache[cacheName] = {
-        type,
-        base,
-        path: path
-      };
-      normalized.push(cacheName);
-    } else {
-      normalized.push(path);
+      throw new Error(`Foreign field "${path}" not allowed in search.`);
     }
   }
-  definition.search.cache = cache;
-  definition.search.fields = normalized;
 }
 function createCacheFields(schema, definition) {
   for (let [cachedField, def] of Object.entries(definition.search.cache)) {
@@ -410,32 +389,12 @@ function applyCacheHook(schema, definition) {
     this.assign(getUpdates(this, paths, definition));
   });
 }
-function resolveSchemaType(schema, path) {
-  if (!path.includes('.')) {
-    return (0, _lodash.get)(schema.obj, path)?.type;
-  }
-  const field = getRefField(schema, path);
-  if (field) {
-    const {
-      type,
-      rest
-    } = field;
-    const Model = _mongoose.default.models[type.options.ref];
-    return resolveSchemaType(Model.schema, rest.join('.'));
-  }
-}
 function isForeignField(schema, path) {
   if (!path.includes('.')) {
     return false;
   }
   return !!getRefField(schema, path);
 }
-function getRefBase(schema, path) {
-  const field = getRefField(schema, path);
-  if (field) {
-    return field.base.join('.');
-  }
-}
 function getRefField(schema, path) {
   const split = path.split('.');
   for (let i = 1; i < split.length; i++) {
@@ -475,9 +434,6 @@ function getCachePaths(definition, filter) {
     return entry[1].path;
   });
 }
-function generateCacheFieldName(field) {
-  return `cached${(0, _lodash.upperFirst)((0, _lodash.camelCase)(field))}`;
-}
 
 // Assertions
 

package/package.json

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

package/src/search.js

@@ -1,15 +1,7 @@
 import yd from '@bedrockio/yada';
 import logger from '@bedrockio/logger';
 import mongoose from 'mongoose';
-import {
-  get,
-  pick,
-  isEmpty,
-  camelCase,
-  upperFirst,
-  escapeRegExp,
-  isPlainObject,
-} from 'lodash';
+import { get, pick, isEmpty, escapeRegExp, isPlainObject } from 'lodash';
 
 import { isDateField, isNumberField, getField } from './utils';
 import { SEARCH_DEFAULTS } from './const';
@@ -24,6 +16,7 @@ const { ObjectId } = mongoose.Types;
 
 export function applySearch(schema, definition) {
   validateDefinition(definition);
+  validateSearchFields(schema, definition);
   applySearchCache(schema, definition);
 
   const { query: searchQuery, fields: searchFields } = definition.search || {};
@@ -318,8 +311,6 @@ function parseRegexQuery(str) {
 // Search field caching
 
 function applySearchCache(schema, definition) {
-  normalizeCacheFields(schema, definition);
-
   if (!definition.search?.cache) {
     return;
   }
@@ -346,13 +337,8 @@ function applySearchCache(schema, definition) {
       const query = {};
 
       if (!force) {
-        const $or = Object.entries(cache).map((entry) => {
-          const [cachedField, def] = entry;
-          const { base } = def;
+        const $or = Object.keys(cache).map((cachedField) => {
           return {
-            [base]: {
-              $exists: true,
-            },
             [cachedField]: {
               $exists: false,
             },
@@ -381,32 +367,18 @@ function applySearchCache(schema, definition) {
   );
 }
 
-function normalizeCacheFields(schema, definition) {
-  const { fields, cache = {} } = definition.search || {};
+function validateSearchFields(schema, definition) {
+  const { fields } = definition.search || {};
+
   if (!fields) {
     return;
   }
 
-  const normalized = [];
-
   for (let path of fields) {
     if (isForeignField(schema, path)) {
-      const cacheName = generateCacheFieldName(path);
-      const type = resolveSchemaType(schema, path);
-      const base = getRefBase(schema, path);
-      cache[cacheName] = {
-        type,
-        base,
-        path: path,
-      };
-      normalized.push(cacheName);
-    } else {
-      normalized.push(path);
+      throw new Error(`Foreign field "${path}" not allowed in search.`);
     }
   }
-
-  definition.search.cache = cache;
-  definition.search.fields = normalized;
 }
 
 function createCacheFields(schema, definition) {
@@ -442,18 +414,6 @@ function applyCacheHook(schema, definition) {
   });
 }
 
-function resolveSchemaType(schema, path) {
-  if (!path.includes('.')) {
-    return get(schema.obj, path)?.type;
-  }
-  const field = getRefField(schema, path);
-  if (field) {
-    const { type, rest } = field;
-    const Model = mongoose.models[type.options.ref];
-    return resolveSchemaType(Model.schema, rest.join('.'));
-  }
-}
-
 function isForeignField(schema, path) {
   if (!path.includes('.')) {
     return false;
@@ -461,13 +421,6 @@ function isForeignField(schema, path) {
   return !!getRefField(schema, path);
 }
 
-function getRefBase(schema, path) {
-  const field = getRefField(schema, path);
-  if (field) {
-    return field.base.join('.');
-  }
-}
-
 function getRefField(schema, path) {
   const split = path.split('.');
   for (let i = 1; i < split.length; i++) {
@@ -511,10 +464,6 @@ function getCachePaths(definition, filter) {
     });
 }
 
-function generateCacheFieldName(field) {
-  return `cached${upperFirst(camelCase(field))}`;
-}
-
 // Assertions
 
 function assertIncludeModule(Model) {

package/types/search.d.ts.map

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