@bedrockio/model 0.7.6 → 0.8.0

package/dist/cjs/search.js

@@ -15,18 +15,13 @@ var _validation = require("./validation");
 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;
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 const {
   ObjectId
 } = _mongoose.default.Types;
 function applySearch(schema, definition) {
   validateDefinition(definition);
   validateSearchFields(schema, definition);
-  applySearchCache(schema, definition);
-  applySearchSync(schema, definition);
   const {
     query: searchQuery,
     fields: searchFields
@@ -305,50 +300,6 @@ function parseRegexQuery(str) {
 
 // Search field caching
 
-function applySearchCache(schema, definition) {
-  if (!definition.search?.cache) {
-    return;
-  }
-  createCacheFields(schema, definition);
-  applyCacheHook(schema, definition);
-  schema.static('syncCacheFields', async function syncCacheFields(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.keys(cache).map(cachedField => {
-        return {
-          [cachedField]: null
-        };
-      });
-      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 validateSearchFields(schema, definition) {
   const {
     fields
@@ -362,62 +313,6 @@ function validateSearchFields(schema, definition) {
     }
   }
 }
-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',
-      path,
-      ...rest
-    } = def;
-    schema.add({
-      [cachedField]: type
-    });
-    schema.obj[cachedField] = {
-      type,
-      ...rest
-    };
-  }
-}
-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));
-  });
-}
-
-// Search field syncing
-
-function applySearchSync(schema, definition) {
-  if (!definition.search?.sync) {
-    return;
-  }
-  schema.post('save', async function postSave() {
-    for (let entry of definition.search.sync) {
-      const {
-        ref,
-        path
-      } = entry;
-      const Model = _mongoose.default.models[ref];
-      const docs = await Model.find({
-        [path]: this.id
-      });
-      await Promise.all(docs.map(async doc => {
-        await doc.save();
-      }));
-    }
-  });
-}
 
 // Utils
 
@@ -425,57 +320,5 @@ function isForeignField(schema, path) {
   if (!path.includes('.')) {
     return false;
   }
-  return !!getRefField(schema, path);
-}
-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.join('.'));
-    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;
-  });
-}
-
-// 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.');
-  }
+  return !!(0, _utils.resolveRefPath)(schema, path);
 }

package/dist/cjs/slug.js

@@ -5,7 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.applySlug = applySlug;
 var _mongoose = _interopRequireDefault(require("mongoose"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 const {
   ObjectId
 } = _mongoose.default.Types;
@@ -26,22 +26,19 @@ function applySlug(schema) {
     });
   });
 }
-function find(Model, str, args, query) {
+function find(Model, str, args, deleted) {
   const isObjectId = str.length === 24 && ObjectId.isValid(str);
   // There is a non-zero chance of a slug colliding with an ObjectId but
   // is exceedingly rare (run of exactly 24 [a-f0-9] chars together
   // without a hyphen) so this should be acceptable.
-  if (!query && isObjectId) {
-    return Model.findById(str, ...args);
+  const query = {};
+  if (isObjectId) {
+    query._id = str;
   } else {
-    query = {
-      ...query
-    };
-    if (isObjectId) {
-      query._id = str;
-    } else {
-      query.slug = str;
-    }
-    return Model.findOne(query, ...args);
+    query.slug = str;
   }
+  return Model.findOne({
+    ...deleted,
+    ...query
+  }, ...args);
 }

package/dist/cjs/soft-delete.js

@@ -9,7 +9,7 @@ exports.hasUniqueConstraints = hasUniqueConstraints;
 var _mongoose = _interopRequireDefault(require("mongoose"));
 var _lodash = require("lodash");
 var _query = require("./query");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 function applySoftDelete(schema) {
   applyQueries(schema);
   applyUniqueConstraints(schema);

package/dist/cjs/testing.js

@@ -8,7 +8,7 @@ exports.getTestModelName = getTestModelName;
 var _mongoose = _interopRequireDefault(require("mongoose"));
 var _schema = require("./schema");
 var _utils = require("./utils");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 let counter = 0;
 
 /**

package/dist/cjs/utils.js

@@ -12,8 +12,13 @@ exports.isMongooseSchema = isMongooseSchema;
 exports.isNumberField = isNumberField;
 exports.isReferenceField = isReferenceField;
 exports.isSchemaTypedef = isSchemaTypedef;
+exports.resolveRefPath = resolveRefPath;
 var _mongoose = _interopRequireDefault(require("mongoose"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const {
+  SchemaTypes
+} = _mongoose.default;
+
 // Mongoose provides an "equals" method on both documents and
 // ObjectIds, however it does not provide a static method to
 // compare two unknown values that may be either, so provide
@@ -95,6 +100,31 @@ function getField(obj, path) {
   return field || {};
 }
 
+// Finds a reference field in a schema and splits
+// the provided path into the local and foreign
+// components of the full path.
+function resolveRefPath(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);
+    let type = schema.path(base.join('.'));
+    if (type instanceof SchemaTypes.Array) {
+      type = type.caster;
+    }
+    if (type instanceof SchemaTypes.ObjectId) {
+      const {
+        ref
+      } = type.options;
+      return {
+        ref,
+        local: base.join('.'),
+        foreign: rest.join('.')
+      };
+    }
+  }
+}
+
 // The same as getField but traverses into the final field
 // as well. In the above example this will return:
 // { type: 'Number' }, given "product.inventory"

package/dist/cjs/validation.js

@@ -18,12 +18,12 @@ var _errors = require("./errors");
 var _softDelete = require("./soft-delete");
 var _utils = require("./utils");
 var _include = require("./include");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 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('{field} must be an id.').tag({
+const OBJECT_ID_SCHEMA = exports.OBJECT_ID_SCHEMA = _yada.default.string().mongo().message('Must be an id.').tag({
   'x-schema': 'ObjectId',
   'x-description': 'A 24 character hexadecimal string representing a Mongo [ObjectId](https://bit.ly/3YPtGlU).'
 });
@@ -33,7 +33,7 @@ const REFERENCE_SCHEMA = _yada.default.allow(OBJECT_ID_SCHEMA, _yada.default.obj
   stripUnknown: true
 }).custom(obj => {
   return obj.id;
-})).message('{field} must be an id or object containing "id" field.').tag({
+})).message('Must be an id or object containing an "id" field.').tag({
   'x-schema': 'Reference',
   'x-description': `
 A 24 character hexadecimal string representing a Mongo [ObjectId](https://bit.ly/3YPtGlU).

package/dist/cjs/warn.js

@@ -5,7 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = warn;
 var _logger = _interopRequireDefault(require("@bedrockio/logger"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 function warn(...lines) {
   if (process.env.ENV_NAME !== 'test') {
     _logger.default.warn(lines.join('\n'));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bedrockio/model",
-  "version": "0.7.6",
+  "version": "0.8.0",
   "description": "Bedrock utilities for model creation.",
   "type": "module",
   "scripts": {
@@ -30,7 +30,7 @@
     "lodash": "^4.17.21"
   },
   "peerDependencies": {
-    "@bedrockio/yada": "^1.2.3",
+    "@bedrockio/yada": "^1.2.7",
     "mongoose": "^8.6.2"
   },
   "devDependencies": {
@@ -38,7 +38,7 @@
     "@babel/core": "^7.20.12",
     "@babel/preset-env": "^7.20.2",
     "@bedrockio/prettier-config": "^1.0.2",
-    "@bedrockio/yada": "^1.2.3",
+    "@bedrockio/yada": "^1.2.7",
     "@shelf/jest-mongodb": "^4.3.2",
     "eslint": "^8.33.0",
     "eslint-plugin-bedrock": "^1.0.26",
@@ -47,10 +47,10 @@
     "mongodb": "^6.5.0",
     "mongoose": "^8.6.2",
     "prettier-eslint": "^15.0.1",
-    "typescript": "^4.9.5"
+    "typescript": "^5.7.2"
   },
   "volta": {
-    "node": "18.14.0",
-    "yarn": "1.22.19"
+    "node": "22.12.0",
+    "yarn": "1.22.22"
   }
 }

package/src/cache.js

@@ -0,0 +1,245 @@
+import mongoose from 'mongoose';
+import { get, once, groupBy } from 'lodash';
+
+import { resolveRefPath } from './utils';
+
+const definitionMap = new Map();
+
+mongoose.plugin(cacheSyncPlugin);
+
+export function applyCache(schema, definition) {
+  definitionMap.set(schema, definition);
+
+  if (!definition.cache) {
+    return;
+  }
+
+  createCacheFields(schema, definition);
+  applyStaticMethods(schema, definition);
+  applyCacheHook(schema, definition);
+}
+
+function createCacheFields(schema, definition) {
+  for (let [cachedField, def] of Object.entries(definition.cache)) {
+    const { type, path, ...rest } = def;
+
+    schema.add({
+      [cachedField]: type,
+    });
+    schema.obj[cachedField] = {
+      ...rest,
+      type,
+      writeAccess: 'none',
+    };
+  }
+}
+
+function applyStaticMethods(schema, definition) {
+  schema.static('syncCacheFields', async function syncCacheFields() {
+    assertIncludeModule(this);
+
+    const fields = resolveCachedFields(schema, definition);
+
+    const hasSynced = fields.some((entry) => {
+      return entry.sync;
+    });
+
+    const query = {};
+
+    if (!hasSynced) {
+      const $or = fields.map((field) => {
+        return {
+          [field.name]: null,
+        };
+      });
+      query.$or = $or;
+    }
+
+    const includes = getIncludes(fields);
+    const docs = await this.find(query).include(includes);
+
+    const ops = docs.flatMap((doc) => {
+      return fields.map((field) => {
+        const { name, sync } = field;
+        const updates = getUpdates(doc, [field]);
+        const filter = {
+          _id: doc._id,
+        };
+        if (!sync) {
+          filter[name] = null;
+        }
+        return {
+          updateOne: {
+            filter,
+            update: {
+              $set: updates,
+            },
+          },
+        };
+      });
+    });
+
+    return await this.bulkWrite(ops);
+  });
+}
+
+function applyCacheHook(schema, definition) {
+  const fields = resolveCachedFields(schema, definition);
+  schema.pre('save', async function () {
+    assertIncludeModule(this.constructor);
+    assertAssignModule(this.constructor);
+
+    const doc = this;
+
+    const changes = fields.filter((field) => {
+      const { sync, local, name } = field;
+      if (sync || doc.isModified(local)) {
+        // Always update if we are actively syncing
+        // or if the field has been changed.
+        return true;
+      } else {
+        // Otherwise only update if the value does
+        // not exist yet.
+        const value = get(doc, name);
+        return Array.isArray(value) ? !value.length : !value;
+      }
+    });
+
+    await this.include(getIncludes(changes));
+    this.assign(getUpdates(doc, changes));
+  });
+}
+
+// Syncing
+
+const syncOperations = {};
+const compiledModels = new Set();
+
+function cacheSyncPlugin(schema) {
+  // Compile sync fields each time a new schema
+  // is registered but only do it one time for.
+  const initialize = once(compileSyncOperations);
+
+  schema.pre('save', async function () {
+    this.$locals.modifiedPaths = this.modifiedPaths();
+  });
+
+  schema.post('save', async function () {
+    initialize();
+
+    // @ts-ignore
+    const { modelName } = this.constructor;
+
+    const ops = syncOperations[modelName] || [];
+    for (let op of ops) {
+      await op(this);
+    }
+  });
+}
+function compileSyncOperations() {
+  for (let Model of Object.values(mongoose.models)) {
+    const { schema } = Model;
+
+    if (compiledModels.has(Model)) {
+      // Model has already been compiled so skip.
+      continue;
+    }
+    const definition = definitionMap.get(schema);
+    const fields = resolveCachedFields(schema, definition);
+
+    for (let [ref, group] of Object.entries(groupBy(fields, 'ref'))) {
+      const hasSynced = group.some((entry) => {
+        return entry.sync;
+      });
+
+      if (!hasSynced) {
+        continue;
+      }
+
+      const fn = async (doc) => {
+        const { modifiedPaths } = doc.$locals;
+        const changes = group.filter((entry) => {
+          return entry.sync && modifiedPaths.includes(entry.foreign);
+        });
+
+        if (changes.length) {
+          const $or = changes.map((change) => {
+            const { local } = change;
+            return {
+              [local]: doc.id,
+            };
+          });
+
+          const docs = await Model.find({
+            $or,
+          });
+
+          await Promise.all(docs.map((doc) => doc.save()));
+        }
+      };
+      syncOperations[ref] ||= [];
+      syncOperations[ref].push(fn);
+    }
+
+    compiledModels.add(Model);
+  }
+}
+
+// Utils
+
+function resolveCachedFields(schema, definition) {
+  const { cache = {} } = definition;
+  return Object.entries(cache).map(([name, def]) => {
+    const { path, sync = false } = def;
+    const resolved = resolveRefPath(schema, path);
+    if (!resolved) {
+      throw new Error(`Could not resolve path ${path}.`);
+    }
+
+    return {
+      ...resolved,
+      name,
+      path,
+      sync,
+    };
+  });
+}
+
+function getUpdates(doc, fields) {
+  const updates = {};
+
+  for (let field of fields) {
+    const { name, path } = field;
+
+    // doc.get will not return virtuals (even with specified options),
+    // so fall back to lodash to ensure they are included here.
+    // https://mongoosejs.com/docs/api/document.html#Document.prototype.get()
+    const value = doc.get(path) ?? get(doc, path);
+
+    updates[name] = value;
+  }
+
+  return updates;
+}
+
+function getIncludes(fields) {
+  const includes = new Set();
+  for (let field of fields) {
+    includes.add(field.local);
+  }
+  return includes;
+}
+
+// Assertions
+
+function assertIncludeModule(Model) {
+  if (!Model.schema.methods.include) {
+    throw new Error('Include module is required for cached fields.');
+  }
+}
+
+function assertAssignModule(Model) {
+  if (!Model.schema.methods.assign) {
+    throw new Error('Assign module is required for cached fields.');
+  }
+}

package/src/include.js

@@ -134,11 +134,21 @@ export function checkSelects(doc, ret) {
 
 // Exported for testing.
 export function getParams(modelName, arg) {
-  const paths = Array.isArray(arg) ? arg : [arg];
+  const paths = resolvePathsArg(arg);
   const node = pathsToNode(paths, modelName);
   return nodeToPopulates(node);
 }
 
+function resolvePathsArg(arg) {
+  if (Array.isArray(arg)) {
+    return arg;
+  } else if (arg instanceof Set) {
+    return Array.from(arg);
+  } else {
+    return [arg];
+  }
+}
+
 // Exported for testing.
 export function getDocumentParams(doc, arg, options = {}) {
   const params = getParams(doc.constructor.modelName, arg);

package/src/schema.js

@@ -5,6 +5,7 @@ import { isSchemaTypedef } from './utils';
 
 import { serializeOptions } from './serialization';
 import { applySlug } from './slug';
+import { applyCache } from './cache';
 import { applySearch } from './search';
 import { applyAssign } from './assign';
 import { applyUpsert } from './upsert';
@@ -58,6 +59,7 @@ export function createSchema(definition, options = {}) {
   applyValidation(schema, definition);
   applyDeleteHooks(schema, definition);
   applySearch(schema, definition);
+  applyCache(schema, definition);
   applyDisallowed(schema);
   applyInclude(schema);
   applyHydrate(schema);