@bedrockio/model 0.2.17 → 0.2.19

package/dist/cjs/search.js

@@ -16,15 +16,19 @@ var _env = require("./env");
 var _query = require("./query");
 var _warn = _interopRequireDefault(require("./warn"));
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const {
+  SchemaTypes
+} = _mongoose.default;
 const {
   ObjectId
 } = _mongoose.default.Types;
 function applySearch(schema, definition) {
   validateDefinition(definition);
+  applySearchCache(schema, definition);
   schema.static('search', function search(body = {}) {
     const options = {
       ..._const.SEARCH_DEFAULTS,
-      ...definition.search,
+      ...definition.search?.query,
       ...body
     };
     const {
@@ -33,7 +37,6 @@ function applySearch(schema, definition) {
       skip = 0,
       limit,
       sort,
-      fields,
       ...rest
     } = options;
     const query = {};
@@ -43,7 +46,7 @@ function applySearch(schema, definition) {
       };
     }
     if (keyword) {
-      Object.assign(query, buildKeywordQuery(schema, keyword, fields));
+      Object.assign(query, buildKeywordQuery(schema, keyword, definition.search?.fields));
     }
     Object.assign(query, normalizeQuery(rest, schema.obj));
     if (_env.debug) {
@@ -162,7 +165,7 @@ function buildKeywordQuery(schema, keyword, fields) {
   } else if (hasTextIndex(schema)) {
     queries = [getTextQuery(keyword)];
   } else {
-    queries = [];
+    throw new Error('No keyword fields defined.');
   }
   if (ObjectId.isValid(keyword)) {
     queries.push({
@@ -284,4 +287,200 @@ function parseRegexQuery(str) {
     $regex,
     $options
   };
+}
+
+// Search field caching
+
+function applySearchCache(schema, definition) {
+  normalizeCacheFields(schema, definition);
+  if (!definition.search?.cache) {
+    return;
+  }
+  createCacheFields(schema, definition);
+  applyCacheHook(schema, definition);
+  schema.static('syncSearchFields', async function syncSearchFields(options = {}) {
+    assertIncludeModule(this);
+    const {
+      force
+    } = options;
+    const {
+      cache = {}
+    } = definition.search || {};
+    const paths = getCachePaths(definition);
+    const cachedFields = Object.keys(cache);
+    if (!cachedFields.length) {
+      throw new Error('No search fields to sync.');
+    }
+    const query = {};
+    if (!force) {
+      const $or = Object.entries(cache).map(entry => {
+        const [cachedField, def] = entry;
+        const {
+          base
+        } = def;
+        return {
+          [base]: {
+            $exists: true
+          },
+          [cachedField]: {
+            $exists: false
+          }
+        };
+      });
+      query.$or = $or;
+    }
+    const docs = await this.find(query).include(paths);
+    const ops = docs.map(doc => {
+      return {
+        updateOne: {
+          filter: {
+            _id: doc._id
+          },
+          update: {
+            $set: getUpdates(doc, paths, definition)
+          }
+        }
+      };
+    });
+    return await this.bulkWrite(ops);
+  });
+}
+function normalizeCacheFields(schema, definition) {
+  const {
+    fields,
+    cache = {}
+  } = 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);
+    }
+  }
+  definition.search.cache = cache;
+  definition.search.fields = normalized;
+}
+function createCacheFields(schema, definition) {
+  for (let [cachedField, def] of Object.entries(definition.search.cache)) {
+    // Fall back to string type for virtuals or not defined.
+    const {
+      type = 'String'
+    } = def;
+    schema.add({
+      [cachedField]: type
+    });
+    schema.obj[cachedField] = {
+      type,
+      readAccess: 'none'
+    };
+  }
+}
+function applyCacheHook(schema, definition) {
+  schema.pre('save', async function () {
+    assertIncludeModule(this.constructor);
+    assertAssignModule(this.constructor);
+    const doc = this;
+    const paths = getCachePaths(definition, (cachedField, def) => {
+      if (def.lazy) {
+        return !(0, _lodash.get)(doc, cachedField);
+      } else {
+        return true;
+      }
+    });
+    await this.include(paths);
+    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++) {
+    const base = split.slice(0, i);
+    const rest = split.slice(i);
+    const type = schema.path(base);
+    if (type instanceof SchemaTypes.ObjectId) {
+      return {
+        type,
+        base,
+        rest
+      };
+    }
+  }
+}
+function getUpdates(doc, paths, definition) {
+  const updates = {};
+  const entries = Object.entries(definition.search.cache).filter(entry => {
+    return paths.includes(entry[1].path);
+  });
+  for (let [cachedField, def] of entries) {
+    // doc.get will not return virtuals (even with specified options),
+    // so use lodash to ensure they are included here.
+    // https://mongoosejs.com/docs/api/document.html#Document.prototype.get()
+    updates[cachedField] = (0, _lodash.get)(doc, def.path);
+  }
+  return updates;
+}
+function getCachePaths(definition, filter) {
+  filter ||= () => true;
+  const {
+    cache
+  } = definition.search || {};
+  return Object.entries(cache).filter(entry => {
+    return filter(...entry);
+  }).map(entry => {
+    return entry[1].path;
+  });
+}
+function generateCacheFieldName(field) {
+  return `cached${(0, _lodash.upperFirst)((0, _lodash.camelCase)(field))}`;
+}
+
+// Assertions
+
+function assertIncludeModule(Model) {
+  if (!Model.schema.methods.include) {
+    throw new Error('Include module is required for cached search fields.');
+  }
+}
+function assertAssignModule(Model) {
+  if (!Model.schema.methods.assign) {
+    throw new Error('Assign module is required for cached search fields.');
+  }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bedrockio/model",
-  "version": "0.2.17",
+  "version": "0.2.19",
   "description": "Bedrock utilities for model creation.",
   "type": "module",
   "scripts": {
@@ -31,7 +31,7 @@
   },
   "peerDependencies": {
     "@bedrockio/yada": "^1.0.39",
-    "mongoose": "^6.9.0 || ^7.6.4"
+    "mongoose": "^7.6.4"
   },
   "devDependencies": {
     "@babel/cli": "^7.20.7",

package/src/delete-hooks.js

@@ -13,9 +13,8 @@ export function applyDeleteHooks(schema, definition) {
     return;
   }
 
-  const cleanLocal = validateCleanLocal(deleteHooks, schema);
-  const cleanForeign = validateCleanForeign(deleteHooks);
   const errorHook = validateError(deleteHooks);
+  const cleanHooks = validateCleanHooks(deleteHooks, schema);
 
   let references;
 
@@ -27,24 +26,21 @@ export function applyDeleteHooks(schema, definition) {
       references ||= getAllReferences(this);
       await errorOnForeignReferences(this, {
         errorHook,
-        cleanForeign,
+        cleanHooks,
         references,
       });
     }
     try {
-      await deleteLocalReferences(this, cleanLocal);
-      await deleteForeignReferences(this, cleanForeign);
+      await deleteReferences(this, cleanHooks);
     } catch (error) {
-      await restoreLocalReferences(this, cleanLocal);
-      await restoreForeignReferences(this);
+      await restoreReferences(this, cleanHooks);
       throw error;
     }
     await deleteFn.apply(this, arguments);
   });
 
   schema.method('restore', async function () {
-    await restoreLocalReferences(this, cleanLocal);
-    await restoreForeignReferences(this);
+    await restoreReferences(this, cleanHooks);
     await restoreFn.apply(this, arguments);
   });
 
@@ -60,45 +56,53 @@ export function applyDeleteHooks(schema, definition) {
 
 // Clean Hook
 
-function validateCleanLocal(deleteHooks, schema) {
-  let { local } = deleteHooks.clean || {};
-  if (!local) {
-    return;
-  }
-  if (typeof local !== 'string' && !Array.isArray(local)) {
-    throw new Error('Local delete hook must be an array.');
+function validateCleanHooks(deleteHooks, schema) {
+  const { clean } = deleteHooks;
+  if (!clean) {
+    return [];
   }
-  if (typeof local === 'string') {
-    local = [local];
+  if (!Array.isArray(clean)) {
+    throw new Error('Delete clean hook must be an array.');
   }
-  for (let name of local) {
-    const pathType = schema.pathType(name);
-    if (pathType !== 'real') {
-      throw new Error(`Delete hook has invalid local reference "${name}".`);
+
+  for (let hook of clean) {
+    const { ref, path, paths } = hook;
+    if (path && typeof path !== 'string') {
+      throw new Error('Clean hook path must be a string.');
+    } else if (paths && !Array.isArray(paths)) {
+      throw new Error('Clean hook paths must be an array.');
+    } else if (!path && !paths) {
+      throw new Error('Clean hook must define either "path" or "paths".');
+    } else if (path && paths) {
+      throw new Error('Clean hook may not define both "path" or "paths".');
+    } else if (ref && typeof ref !== 'string') {
+      throw new Error('Clean hook ref must be a string.');
+    } else if (!ref) {
+      validateLocalCleanHook(hook, schema);
     }
   }
-  return local;
+
+  return clean;
 }
 
-function validateCleanForeign(deleteHooks) {
-  const { foreign } = deleteHooks.clean || {};
-  if (!foreign) {
-    return;
-  }
-  if (typeof foreign !== 'object') {
-    throw new Error('Foreign delete hook must be an object.');
-  }
-  for (let [modelName, arg] of Object.entries(foreign)) {
-    if (typeof arg === 'object') {
-      const { $and, $or } = arg;
-      if ($and && $or) {
-        throw new Error(
-          `Cannot define both $or and $and in a delete hook for model ${modelName}.`
-        );
-      }
+function validateLocalCleanHook(hook, schema) {
+  const paths = getHookPaths(hook);
+  for (let path of paths) {
+    if (schema.pathType(path) !== 'real') {
+      throw new Error(`Invalid reference in local delete hook: "${path}".`);
     }
   }
-  return foreign;
+}
+
+function getHookPaths(hook) {
+  const { path, paths } = hook;
+  if (path) {
+    return [path];
+  } else if (paths) {
+    return paths;
+  } else {
+    return [];
+  }
 }
 
 function validateError(deleteHooks) {
@@ -170,11 +174,17 @@ async function errorOnForeignReferences(doc, options) {
 }
 
 function referenceIsAllowed(model, options) {
-  const { cleanForeign = {} } = options;
-  const { only, except } = options?.errorHook || {};
-  if (model.modelName in cleanForeign) {
+  const { modelName } = model;
+  const { cleanHooks } = options;
+
+  const hasCleanHook = cleanHooks.some((hook) => {
+    return hook.ref === modelName;
+  });
+  if (hasCleanHook) {
     return true;
   }
+
+  const { only, except } = options?.errorHook || {};
   if (only) {
     return !only.includes(model.modelName);
   } else if (except) {
@@ -227,16 +237,54 @@ function getModelReferences(model, targetName) {
   return paths;
 }
 
-// Deletion
+// Delete
 
-async function deleteLocalReferences(doc, arr) {
-  if (!arr) {
-    return;
+async function deleteReferences(doc, hooks) {
+  for (let hook of hooks) {
+    if (hook.ref) {
+      await deleteForeignReferences(doc, hook);
+    } else {
+      await deleteLocalReferences(doc, hook);
+    }
   }
-  for (let name of arr) {
-    await doc.populate(name);
+}
+
+async function deleteForeignReferences(doc, hook) {
+  const { ref, path, paths, query } = hook;
+
+  const { id } = doc;
+  if (!id) {
+    throw new Error(`Refusing to apply delete hook to document without id.`);
+  }
+
+  const Model = mongoose.models[ref];
+  if (!Model) {
+    throw new Error(`Unknown model: "${ref}".`);
+  }
+
+  if (path) {
+    await runDeletes(Model, doc, {
+      ...query,
+      [path]: id,
+    });
+  } else if (paths) {
+    await runDeletes(Model, doc, {
+      $or: paths.map((refName) => {
+        return {
+          ...query,
+          [refName]: id,
+        };
+      }),
+    });
+  }
+}
+
+async function deleteLocalReferences(doc, hook) {
+  const paths = getHookPaths(hook);
+  await doc.populate(paths);
+  for (let path of paths) {
+    const value = doc.get(path);
 
-    const value = doc.get(name);
     if (!value) {
       continue;
     }
@@ -248,39 +296,6 @@ async function deleteLocalReferences(doc, arr) {
   }
 }
 
-async function deleteForeignReferences(doc, refs) {
-  if (!refs) {
-    return;
-  }
-  const { id } = doc;
-  if (!id) {
-    throw new Error(`Refusing to apply delete hook to document without id.`);
-  }
-  for (let [modelName, arg] of Object.entries(refs)) {
-    const Model = mongoose.models[modelName];
-    if (typeof arg === 'string') {
-      await runDeletes(Model, doc, {
-        [arg]: id,
-      });
-    } else if (Array.isArray(arg)) {
-      await runDeletes(Model, doc, {
-        $or: mapArrayQuery(arg, id),
-      });
-    } else {
-      const { $and, $or } = arg;
-      if ($and) {
-        await runDeletes(Model, doc, {
-          $and: mapArrayQuery($and, id),
-        });
-      } else if ($or) {
-        await runDeletes(Model, doc, {
-          $or: mapArrayQuery($or, id),
-        });
-      }
-    }
-  }
-}
-
 async function runDeletes(Model, refDoc, query) {
   const docs = await Model.find(query);
   for (let doc of docs) {
@@ -292,33 +307,14 @@ async function runDeletes(Model, refDoc, query) {
   }
 }
 
-function mapArrayQuery(arr, id) {
-  return arr.map((refName) => {
-    return {
-      [refName]: id,
-    };
-  });
-}
-
 // Restore
 
-async function restoreLocalReferences(refDoc, arr) {
-  if (!arr) {
-    return;
-  }
-  for (let name of arr) {
-    const { ref } = getInnerField(refDoc.constructor.schema.obj, name);
-    const value = refDoc.get(name);
-    const ids = Array.isArray(value) ? value : [value];
-    const Model = mongoose.models[ref];
-
-    // @ts-ignore
-    const docs = await Model.findDeleted({
-      _id: { $in: ids },
-    });
-
-    for (let doc of docs) {
-      await doc.restore();
+async function restoreReferences(doc, hooks) {
+  for (let hook of hooks) {
+    if (hook.ref) {
+      await restoreForeignReferences(doc);
+    } else {
+      await restoreLocalReferences(doc, hook);
     }
   }
 }
@@ -344,3 +340,23 @@ async function restoreForeignReferences(refDoc) {
 
   refDoc.deletedRefs = [];
 }
+
+async function restoreLocalReferences(refDoc, hook) {
+  const paths = getHookPaths(hook);
+
+  for (let path of paths) {
+    const { ref } = getInnerField(refDoc.constructor.schema.obj, path);
+    const value = refDoc.get(path);
+    const ids = Array.isArray(value) ? value : [value];
+    const Model = mongoose.models[ref];
+
+    // @ts-ignore
+    const docs = await Model.findDeleted({
+      _id: { $in: ids },
+    });
+
+    for (let doc of docs) {
+      await doc.restore();
+    }
+  }
+}

package/src/include.js

@@ -228,15 +228,20 @@ function setNodePath(node, options) {
           node[key] = null;
         }
       } else if (type === 'virtual') {
-        node[key] ||= {};
         const virtual = schema.virtual(key);
-        setNodePath(node[key], {
-          // @ts-ignore
-          modelName: virtual.options.ref,
-          path: path.slice(parts.length),
-          depth: depth + 1,
-          exclude,
-        });
+        // @ts-ignore
+        const ref = virtual.options.ref;
+
+        if (ref) {
+          node[key] ||= {};
+          setNodePath(node[key], {
+            // @ts-ignore
+            modelName: ref,
+            path: path.slice(parts.length),
+            depth: depth + 1,
+            exclude,
+          });
+        }
         halt = true;
       } else if (type !== 'nested') {
         throw new Error(`Unknown path on ${modelName}: ${key}.`);