@bedrockio/model 0.18.0 → 0.18.2

package/.claude/settings.local.json

@@ -0,0 +1,15 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(yarn test:*)",
+      "Bash(yarn list:*)",
+      "WebSearch",
+      "WebFetch(domain:www.npmjs.com)",
+      "WebFetch(domain:gist.github.com)",
+      "WebFetch(domain:mongoosejs.com)",
+      "WebFetch(domain:github.com)"
+    ],
+    "deny": [],
+    "ask": []
+  }
+}

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+## 0.18.2
+
+- Further fix for `reload` not working with delete hooks.
+- Better detection of literal `type` fields.
+- Schema refactor.
+
+## 0.18.1
+
+- Added `export` for dumping documents and to support reload.
+- Fix for `include` not working on nested virtuals.
+- Fixes for `reload`.
+
 ## 0.18.0
 
 - Added `reload`.

package/dist/cjs/cache.js

@@ -3,6 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.addCacheFields = addCacheFields;
 exports.applyCache = applyCache;
 var _lodash = require("lodash");
 var _mongoose = _interopRequireDefault(require("mongoose"));
@@ -10,32 +11,34 @@ var _utils = require("./utils");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 const definitionMap = new Map();
 _mongoose.default.plugin(cacheSyncPlugin);
-function applyCache(schema, definition) {
-  definitionMap.set(schema, definition);
-  if (!definition.cache) {
+function addCacheFields(definition) {
+  const {
+    cache
+  } = definition;
+  if (!cache) {
     return;
   }
-  createCacheFields(schema, definition);
-  applyStaticMethods(schema, definition);
-  applyCacheHook(schema, definition);
-}
-function createCacheFields(schema, definition) {
-  for (let [cachedField, def] of Object.entries(definition.cache)) {
+  for (let [cachedField, def] of Object.entries(cache)) {
     const {
       type,
       path,
       ...rest
     } = def;
-    schema.add({
-      [cachedField]: type
-    });
-    schema.obj[cachedField] = {
-      ...rest,
+    definition.attributes[cachedField] = {
       type,
+      ...rest,
       writeAccess: 'none'
     };
   }
 }
+function applyCache(schema, definition) {
+  definitionMap.set(schema, definition);
+  if (!definition.cache) {
+    return;
+  }
+  applyStaticMethods(schema, definition);
+  applyCacheHook(schema, definition);
+}
 function applyStaticMethods(schema, definition) {
   schema.static('syncCacheFields', async function syncCacheFields() {
     assertIncludeModule(this);

package/dist/cjs/delete-hooks.js

@@ -3,6 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.addDeletedFields = addDeletedFields;
 exports.applyDeleteHooks = applyDeleteHooks;
 var _lodash = require("lodash");
 var _mongoose = _interopRequireDefault(require("mongoose"));
@@ -12,6 +13,18 @@ function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e
 const {
   ObjectId: SchemaObjectId
 } = _mongoose.default.Schema.Types;
+function addDeletedFields(definition) {
+  let {
+    onDelete: deleteHooks
+  } = definition;
+  if (!deleteHooks) {
+    return;
+  }
+  definition.attributes['deletedRefs'] = [{
+    _id: 'ObjectId',
+    ref: 'String'
+  }];
+}
 function applyDeleteHooks(schema, definition) {
   let {
     onDelete: deleteHooks
@@ -45,12 +58,6 @@ function applyDeleteHooks(schema, definition) {
     await restoreReferences(this, cleanHooks);
     await restoreFn.apply(this, arguments);
   });
-  schema.add({
-    deletedRefs: [{
-      _id: 'ObjectId',
-      ref: 'String'
-    }]
-  });
 }
 
 // Clean Hook

package/dist/cjs/export.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.applyExport = applyExport;
+var _lodash = require("lodash");
+function applyExport(schema) {
+  schema.method('export', function () {
+    const result = {};
+    this.constructor.schema.eachPath(schemaPath => {
+      const value = this.get(schemaPath);
+      if (value !== undefined) {
+        (0, _lodash.set)(result, schemaPath, value);
+      }
+    });
+    return result;
+  });
+}

package/dist/cjs/include.js

@@ -162,16 +162,21 @@ function getDocumentParams(doc, arg, options = {}) {
   const params = getParams(doc.constructor.modelName, arg);
   if (!options.force) {
     params.populate = params.populate.filter(p => {
-      return !isDocumentPopulated(doc, p);
+      return !isPopulated(doc, p);
     });
   }
   return params;
 }
-function isDocumentPopulated(doc, params) {
-  if (doc.populated(params.path)) {
-    const sub = doc.get(params.path);
+function isPopulated(arg, params) {
+  if (Array.isArray(arg)) {
+    return arg.every(el => {
+      return isPopulated(el, params);
+    });
+  }
+  if (arg.populated(params.path)) {
+    const sub = arg.get(params.path);
     return params.populate.every(p => {
-      return isDocumentPopulated(sub, p);
+      return isPopulated(sub, p);
     });
   } else {
     return false;

package/dist/cjs/reload.js

@@ -12,19 +12,53 @@ function applyReload(schema) {
     const paths = getPopulatedPaths(this);
     const doc = await this.constructor.findById(this.id).include(paths);
     if (!doc) {
-      throw new Error('Document deleted');
+      throw new Error('Document does not exist');
+    }
+    this.overwrite(doc.export());
+
+    // Include on the query above will not work
+    // for virtuals so handle separately here.
+    for (const path of getVirtualReferencePaths(doc)) {
+      await doc.include(path);
+      this.set(path, doc[path]);
+    }
+
+    // All data reloaded so mark as unmodified.
+    for (const path of this.modifiedPaths()) {
+      this.unmarkModified(path);
     }
-    this.overwrite(doc);
   });
 }
-function getPopulatedPaths(doc) {
-  return getReferencePaths(doc.constructor.schema).filter(path => {
-    const value = doc.get(path);
-    return value && !_mongoose.default.isObjectIdOrHexString(value);
+function getPopulatedPaths(doc, base = []) {
+  const schema = doc.constructor.schema;
+  return getReferencePaths(schema).filter(name => {
+    return doc.populated(name);
+  }).flatMap(name => {
+    const path = [...base, name];
+    const value = doc.get(name);
+    const inner = Array.isArray(value) ? value[0] : value;
+    return [path.join('.'), ...getPopulatedPaths(inner, path)];
   });
 }
 function getReferencePaths(schema) {
+  return [...getRealReferencePaths(schema), ...getVirtualReferencePaths(schema)];
+}
+function getRealReferencePaths(schema) {
   return (0, _utils.getSchemaPaths)(schema).filter(path => {
     return (0, _utils.isReferenceField)(schema, path);
   });
+}
+function getVirtualReferencePaths(arg) {
+  const schema = resolveSchema(arg);
+  return Object.keys(schema.virtuals).filter(key => {
+    return schema.virtuals[key].options?.ref;
+  });
+}
+function resolveSchema(arg) {
+  if (arg instanceof _mongoose.default.Document) {
+    // @ts-ignore
+    return arg.constructor.schema;
+  } else if (arg instanceof _mongoose.default.Schema) {
+    return arg;
+  }
 }

package/dist/cjs/schema.js

@@ -12,6 +12,7 @@ var _cache = require("./cache");
 var _clone = require("./clone");
 var _deleteHooks = require("./delete-hooks");
 var _disallowed = require("./disallowed");
+var _export = require("./export");
 var _hydrate = require("./hydrate");
 var _include = require("./include");
 var _reload = require("./reload");
@@ -32,7 +33,9 @@ function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e
  * @returns mongoose.Schema
  */
 function createSchema(definition, options = {}) {
-  const schema = new _mongoose.default.Schema(attributesToMongoose({
+  (0, _cache.addCacheFields)(definition);
+  (0, _deleteHooks.addDeletedFields)(definition);
+  const attributes = normalizeAttributes({
     ...definition.attributes,
     // Although timestamps are being set below, we still need to add
     // them to the schema so that validation can be generated for them,
@@ -44,7 +47,9 @@ function createSchema(definition, options = {}) {
       type: 'Boolean',
       default: false
     }
-  }), {
+  });
+  applyExtensions(attributes);
+  const schema = new _mongoose.default.Schema(attributes, {
     timestamps: true,
     toJSON: _serialization.serializeOptions,
     toObject: _serialization.serializeOptions,
@@ -60,6 +65,7 @@ function createSchema(definition, options = {}) {
   (0, _cache.applyCache)(schema, definition);
   (0, _clone.applyClone)(schema);
   (0, _reload.applyReload)(schema);
+  (0, _export.applyExport)(schema);
   (0, _disallowed.applyDisallowed)(schema);
   (0, _include.applyInclude)(schema);
   (0, _hydrate.applyHydrate)(schema);
@@ -73,19 +79,9 @@ function normalizeAttributes(arg, path = []) {
     return arg;
   } else if (typeof arg === 'function') {
     throw new Error('Native functions are not allowed as types.');
-  } else if (typeof arg === 'string') {
-    return normalizeSchemaTypedef({
-      type: arg
-    }, path);
-  } else if (Array.isArray(arg)) {
-    return normalizeSchemaTypedef({
-      type: arg
-    }, path);
+  } else if (isTypedefInput(arg)) {
+    return normalizeTypedef(arg, path);
   } else if (typeof arg === 'object') {
-    assertRefs(arg, path);
-    if ((0, _utils.isSchemaTypedef)(arg)) {
-      return normalizeSchemaTypedef(arg, path);
-    }
     const attributes = {};
     for (let [key, val] of Object.entries(arg)) {
       attributes[key] = normalizeAttributes(val, [...path, key]);
@@ -93,68 +89,74 @@ function normalizeAttributes(arg, path = []) {
     return attributes;
   }
 }
-function normalizeSchemaTypedef(typedef, path) {
-  const {
-    type
-  } = typedef;
-  if (Array.isArray(type)) {
-    typedef.type = normalizeArrayAttributes(type, path);
-  } else if (typeof type === 'object') {
-    typedef.type = normalizeAttributes(type, path);
-  } else {
-    assertSchemaType(type, path);
-  }
-  if (typedef.type === 'String') {
-    typedef.trim ??= true;
-  }
-  return typedef;
-}
 function normalizeArrayAttributes(arr, path) {
   return arr.map((el, i) => {
     return normalizeAttributes(el, [...path, i]);
   });
 }
-function attributesToMongoose(attributes) {
-  if (typeof attributes === 'string') {
-    return attributes;
-  } else if (Array.isArray(attributes)) {
-    return attributes.map(attributesToMongoose);
+function normalizeTypedef(arg, path) {
+  const typedef = arg.type ? arg : {
+    type: arg
+  };
+  if (Array.isArray(typedef.type)) {
+    // Normalize all inner fields.
+    typedef.type = normalizeArrayAttributes(typedef.type, path);
+  } else if (typeof typedef.type === 'object') {
+    // Normalize literal "type" field.
+    typedef.type = normalizeAttributes(typedef.type, path);
+  } else if (isExtendedSyntax(typedef)) {
+    // Normalize extended syntax: type "Object" or "Array".
+    typedef.attributes = normalizeAttributes(typedef.attributes, path);
   }
-  attributes = normalizeAttributes(attributes);
-  let definition = {};
-  const isTypedef = (0, _utils.isSchemaTypedef)(attributes);
-  for (let [key, val] of Object.entries(attributes)) {
-    const type = typeof val;
-    if (isTypedef) {
-      if (key === 'type' && type !== 'function') {
-        val = attributesToMongoose(val);
-      } else if (key === 'match' && type === 'string') {
-        // Convert match field to RegExp that cannot be expressed in JSON.
-        val = parseRegExp(val);
-      } else if (key === 'validate' && type === 'string') {
-        // Allow custom mongoose validation function that derives from the schema.
-        val = (0, _validation.getNamedValidator)(val);
-      } else if (key === 'attributes' && type === 'object') {
-        val = attributesToMongoose(val);
-      }
-    } else if (Array.isArray(val)) {
-      val = val.map(attributesToMongoose);
-    } else if ((0, _lodash.isPlainObject)(val)) {
-      if (isScopeExtension(val)) {
-        applyScopeExtension(val, definition);
-        continue;
-      } else {
-        val = attributesToMongoose(val);
-      }
+  if (typedef.type === 'String') {
+    // Auto-apply trim to string fields.
+    typedef.trim ??= true;
+    if (typeof typedef.match === 'string') {
+      // Convert string RegExp so that
+      // it can be expressed in JSON.
+      typedef.match = parseRegExp(typedef.match);
     }
-    definition[key] = val;
   }
-  if (isTypedef) {
-    applyExtensions(definition);
+  assertSchemaType(typedef, path);
+  assertObjectRefs(typedef, path);
+  return typedef;
+}
+function isTypedefInput(arg) {
+  if (typeof arg === 'string') {
+    // "Number" as shorthand for a typedef.
+    return true;
+  } else if (Array.isArray(arg)) {
+    // Array signals an array field with inner schema.
+    return true;
+  } else if (hasLiteralTypeField(arg)) {
+    // An object with a literal "type" field.
+    return false;
   }
-  return definition;
+  return (0, _utils.isSchemaTypedef)(arg);
 }
-function assertSchemaType(type, path) {
+
+// Detects input like:
+// {
+//   "type": "String",
+//   "name": "String",
+// }
+// Which is not intended to be a typedef.
+function hasLiteralTypeField(arg) {
+  const {
+    type,
+    ...rest
+  } = arg || {};
+  if (!isMongooseType(type)) {
+    return false;
+  }
+  return Object.values(rest).some(key => {
+    return isMongooseType(key);
+  });
+}
+function assertSchemaType(typedef, path) {
+  const {
+    type
+  } = typedef;
   if (typeof type === 'string') {
     if (!isMongooseType(type)) {
       const p = path.join('.');
@@ -167,33 +169,59 @@ function assertSchemaType(type, path) {
     }
   }
 }
-function assertRefs(field, path) {
+function assertObjectRefs(typedef, path) {
   const {
     type,
-    ref,
-    refPath
-  } = field;
+    ref
+  } = typedef;
   const p = path.join('.');
-  if (isObjectIdType(type) && !ref && !refPath) {
+  if (requiresRef(typedef, path)) {
     throw new Error(`Ref must be passed for "${p}".`);
+    // TODO: what is the middle part doing here??
   } else if (ref && !isMongooseType(ref) && !isObjectIdType(type)) {
     throw new Error(`Ref field "${p}" must be type "ObjectId".`);
   }
 }
-function camelUpper(str) {
-  return (0, _lodash.capitalize)((0, _lodash.camelCase)(str));
-}
-function isObjectIdType(type) {
-  return type === 'ObjectId' || type === _mongoose.default.Schema.Types.ObjectId;
-}
-function isMongooseType(type) {
-  return !!_mongoose.default.Schema.Types[type];
+function requiresRef(typedef, path) {
+  const {
+    type,
+    ref,
+    refPath
+  } = typedef;
+
+  // Allow "_id" to not have a ref for the
+  // delete hooks module to function.
+  if ((0, _lodash.last)(path) === '_id') {
+    return false;
+  }
+  return isObjectIdType(type) && !ref && !refPath;
 }
-function applyExtensions(typedef) {
-  applySyntaxExtensions(typedef);
-  applyUniqueExtension(typedef);
-  applyTupleExtension(typedef);
-  applyDateExtension(typedef);
+
+// Extensions
+
+function applyExtensions(arg) {
+  if ((0, _utils.isSchemaTypedef)(arg)) {
+    applySyntaxExtensions(arg);
+    applyValidateExtension(arg);
+    applyUniqueExtension(arg);
+    applyTupleExtension(arg);
+    applyDateExtension(arg);
+    if (Array.isArray(arg.type)) {
+      for (let field of arg.type) {
+        applyExtensions(field);
+      }
+      applyArrayValidators(arg);
+      applyOptionHoisting(arg);
+    }
+  } else if ((0, _lodash.isPlainObject)(arg)) {
+    for (let [key, value] of Object.entries(arg)) {
+      if (isScopeExtension(value)) {
+        applyScopeExtension(value, arg, key);
+      } else {
+        applyExtensions(value);
+      }
+    }
+  }
 }
 function applySyntaxExtensions(typedef) {
   const {
@@ -201,14 +229,13 @@ function applySyntaxExtensions(typedef) {
     attributes
   } = typedef;
   if (isExtendedSyntax(typedef)) {
-    typedef.type = new _mongoose.default.Schema(attributes);
+    applyExtensions(attributes);
     if (type === 'Array') {
-      typedef.type = [typedef.type];
+      typedef.type = [attributes];
+    } else if (type === 'Object') {
+      typedef.type = new _mongoose.default.Schema(attributes);
     }
-  }
-  if (Array.isArray(typedef.type)) {
-    applyArrayValidators(typedef);
-    applyOptionHoisting(typedef);
+    delete typedef['attributes'];
   }
 }
 
@@ -222,32 +249,42 @@ function isExtendedSyntax(typedef) {
     type,
     attributes
   } = typedef;
-  return attributes && (type === 'Object' || type === 'Array');
+  if (!attributes) {
+    return false;
+  }
+  return type === 'Object' || type === 'Array' || type === 'Scope';
 }
 function isScopeExtension(arg) {
   return (0, _utils.isSchemaTypedef)(arg) && arg.type === 'Scope';
 }
-function applyScopeExtension(typedef, definition) {
+function applyScopeExtension(typedef, parent, name) {
   const {
     type,
     attributes,
-    ...options
+    ...rest
   } = typedef;
-  for (let [key, val] of Object.entries(normalizeAttributes(attributes))) {
-    if ((0, _utils.isSchemaTypedef)(val)) {
-      val = {
-        ...val,
-        ...options
+  for (let [key, value] of Object.entries(attributes)) {
+    if ((0, _utils.isSchemaTypedef)(value)) {
+      // If the child is a typedef then apply
+      // options directly to the field.
+      applyExtensions(value);
+      parent[key] = {
+        ...value,
+        ...rest
       };
     } else {
-      val = {
+      // If the child is a nested object then
+      // need to use extended object syntax.
+      const typedef = {
         type: 'Object',
-        attributes: val,
-        ...options
+        attributes: value,
+        ...rest
       };
+      applyExtensions(typedef);
+      parent[key] = typedef;
     }
-    definition[key] = attributesToMongoose(val);
   }
+  delete parent[name];
 }
 
 // Extended tuple syntax. Return mixed type and set validator.
@@ -279,6 +316,16 @@ function applyDateExtension(typedef) {
   }
 }
 
+// Apply custom mongoose validation by name.
+function applyValidateExtension(typedef) {
+  const {
+    validate
+  } = typedef;
+  if (typeof validate === 'string') {
+    typedef.validate = (0, _validation.getNamedValidator)(typedef.validate);
+  }
+}
+
 // Intercepts "unique" options and changes to "softUnique".
 function applyUniqueExtension(typedef) {
   if (typedef.unique === true) {
@@ -318,12 +365,9 @@ function validateMaxLength(max) {
     }
   };
 }
-function chain(fn1, fn2) {
-  return (...args) => {
-    fn1?.(...args);
-    fn2?.(...args);
-  };
-}
+
+// Regex Parsing
+
 const REG_MATCH = /^\/(.+)\/(\w+)$/;
 function parseRegExp(str) {
   const match = str.match(REG_MATCH);
@@ -332,4 +376,22 @@ function parseRegExp(str) {
   }
   const [, source, flags] = match;
   return RegExp(source, flags);
+}
+
+// Utils
+
+function camelUpper(str) {
+  return (0, _lodash.capitalize)((0, _lodash.camelCase)(str));
+}
+function isObjectIdType(type) {
+  return type === 'ObjectId' || type === _mongoose.default.Schema.Types.ObjectId;
+}
+function isMongooseType(type) {
+  return !!_mongoose.default.Schema.Types[type];
+}
+function chain(fn1, fn2) {
+  return (...args) => {
+    fn1?.(...args);
+    fn2?.(...args);
+  };
 }

package/package.json

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

package/src/cache.js

@@ -7,33 +7,34 @@ const definitionMap = new Map();
 
 mongoose.plugin(cacheSyncPlugin);
 
-export function applyCache(schema, definition) {
-  definitionMap.set(schema, definition);
+export function addCacheFields(definition) {
+  const { cache } = definition;
 
-  if (!definition.cache) {
+  if (!cache) {
     return;
   }
 
-  createCacheFields(schema, definition);
-  applyStaticMethods(schema, definition);
-  applyCacheHook(schema, definition);
-}
-
-function createCacheFields(schema, definition) {
-  for (let [cachedField, def] of Object.entries(definition.cache)) {
+  for (let [cachedField, def] of Object.entries(cache)) {
     const { type, path, ...rest } = def;
-
-    schema.add({
-      [cachedField]: type,
-    });
-    schema.obj[cachedField] = {
-      ...rest,
+    definition.attributes[cachedField] = {
       type,
+      ...rest,
       writeAccess: 'none',
     };
   }
 }
 
+export function applyCache(schema, definition) {
+  definitionMap.set(schema, definition);
+
+  if (!definition.cache) {
+    return;
+  }
+
+  applyStaticMethods(schema, definition);
+  applyCacheHook(schema, definition);
+}
+
 function applyStaticMethods(schema, definition) {
   schema.static('syncCacheFields', async function syncCacheFields() {
     assertIncludeModule(this);

package/src/delete-hooks.js

@@ -6,6 +6,21 @@ import { getInnerField } from './utils';
 
 const { ObjectId: SchemaObjectId } = mongoose.Schema.Types;
 
+export function addDeletedFields(definition) {
+  let { onDelete: deleteHooks } = definition;
+
+  if (!deleteHooks) {
+    return;
+  }
+
+  definition.attributes['deletedRefs'] = [
+    {
+      _id: 'ObjectId',
+      ref: 'String',
+    },
+  ];
+}
+
 export function applyDeleteHooks(schema, definition) {
   let { onDelete: deleteHooks } = definition;
 
@@ -43,15 +58,6 @@ export function applyDeleteHooks(schema, definition) {
     await restoreReferences(this, cleanHooks);
     await restoreFn.apply(this, arguments);
   });
-
-  schema.add({
-    deletedRefs: [
-      {
-        _id: 'ObjectId',
-        ref: 'String',
-      },
-    ],
-  });
 }
 
 // Clean Hook

package/src/export.js

@@ -0,0 +1,14 @@
+import { set } from 'lodash';
+
+export function applyExport(schema) {
+  schema.method('export', function () {
+    const result = {};
+    this.constructor.schema.eachPath((schemaPath) => {
+      const value = this.get(schemaPath);
+      if (value !== undefined) {
+        set(result, schemaPath, value);
+      }
+    });
+    return result;
+  });
+}

package/src/include.js

@@ -146,18 +146,23 @@ export function getDocumentParams(doc, arg, options = {}) {
 
   if (!options.force) {
     params.populate = params.populate.filter((p) => {
-      return !isDocumentPopulated(doc, p);
+      return !isPopulated(doc, p);
     });
   }
 
   return params;
 }
 
-function isDocumentPopulated(doc, params) {
-  if (doc.populated(params.path)) {
-    const sub = doc.get(params.path);
+function isPopulated(arg, params) {
+  if (Array.isArray(arg)) {
+    return arg.every((el) => {
+      return isPopulated(el, params);
+    });
+  }
+  if (arg.populated(params.path)) {
+    const sub = arg.get(params.path);
     return params.populate.every((p) => {
-      return isDocumentPopulated(sub, p);
+      return isPopulated(sub, p);
     });
   } else {
     return false;

package/src/reload.js

@@ -6,25 +6,70 @@ import { isReferenceField } from './utils';
 export function applyReload(schema) {
   schema.method('reload', async function reload() {
     const paths = getPopulatedPaths(this);
+
     const doc = await this.constructor.findById(this.id).include(paths);
 
     if (!doc) {
-      throw new Error('Document deleted');
+      throw new Error('Document does not exist');
+    }
+
+    this.overwrite(doc.export());
+
+    // Include on the query above will not work
+    // for virtuals so handle separately here.
+    for (const path of getVirtualReferencePaths(doc)) {
+      await doc.include(path);
+      this.set(path, doc[path]);
     }
 
-    this.overwrite(doc);
+    // All data reloaded so mark as unmodified.
+    for (const path of this.modifiedPaths()) {
+      this.unmarkModified(path);
+    }
   });
 }
 
-function getPopulatedPaths(doc) {
-  return getReferencePaths(doc.constructor.schema).filter((path) => {
-    const value = doc.get(path);
-    return value && !mongoose.isObjectIdOrHexString(value);
-  });
+function getPopulatedPaths(doc, base = []) {
+  const schema = doc.constructor.schema;
+  return getReferencePaths(schema)
+    .filter((name) => {
+      return doc.populated(name);
+    })
+    .flatMap((name) => {
+      const path = [...base, name];
+
+      const value = doc.get(name);
+      const inner = Array.isArray(value) ? value[0] : value;
+
+      return [path.join('.'), ...getPopulatedPaths(inner, path)];
+    });
 }
 
 function getReferencePaths(schema) {
+  return [
+    ...getRealReferencePaths(schema),
+    ...getVirtualReferencePaths(schema),
+  ];
+}
+
+function getRealReferencePaths(schema) {
   return getSchemaPaths(schema).filter((path) => {
     return isReferenceField(schema, path);
   });
 }
+
+function getVirtualReferencePaths(arg) {
+  const schema = resolveSchema(arg);
+  return Object.keys(schema.virtuals).filter((key) => {
+    return schema.virtuals[key].options?.ref;
+  });
+}
+
+function resolveSchema(arg) {
+  if (arg instanceof mongoose.Document) {
+    // @ts-ignore
+    return arg.constructor.schema;
+  } else if (arg instanceof mongoose.Schema) {
+    return arg;
+  }
+}

package/src/schema.js

@@ -1,11 +1,12 @@
-import { camelCase, capitalize, isPlainObject, pick } from 'lodash';
+import { camelCase, capitalize, isPlainObject, last, pick } from 'lodash';
 import mongoose from 'mongoose';
 
 import { applyAssign } from './assign';
-import { applyCache } from './cache';
+import { addCacheFields, applyCache } from './cache';
 import { applyClone } from './clone';
-import { applyDeleteHooks } from './delete-hooks';
+import { addDeletedFields, applyDeleteHooks } from './delete-hooks';
 import { applyDisallowed } from './disallowed';
+import { applyExport } from './export';
 import { applyHydrate } from './hydrate';
 import { applyInclude } from './include';
 import { applyReload } from './reload';
@@ -31,28 +32,32 @@ import {
  * @returns mongoose.Schema
  */
 export function createSchema(definition, options = {}) {
-  const schema = new mongoose.Schema(
-    attributesToMongoose({
-      ...definition.attributes,
-
-      // Although timestamps are being set below, we still need to add
-      // them to the schema so that validation can be generated for them,
-      // namely in getSearchValidation.
-      createdAt: 'Date',
-      updatedAt: 'Date',
-      deletedAt: 'Date',
-      deleted: {
-        type: 'Boolean',
-        default: false,
-      },
-    }),
-    {
-      timestamps: true,
-      toJSON: serializeOptions,
-      toObject: serializeOptions,
-      ...options,
+  addCacheFields(definition);
+  addDeletedFields(definition);
+
+  const attributes = normalizeAttributes({
+    ...definition.attributes,
+
+    // Although timestamps are being set below, we still need to add
+    // them to the schema so that validation can be generated for them,
+    // namely in getSearchValidation.
+    createdAt: 'Date',
+    updatedAt: 'Date',
+    deletedAt: 'Date',
+    deleted: {
+      type: 'Boolean',
+      default: false,
     },
-  );
+  });
+
+  applyExtensions(attributes);
+
+  const schema = new mongoose.Schema(attributes, {
+    timestamps: true,
+    toJSON: serializeOptions,
+    toObject: serializeOptions,
+    ...options,
+  });
 
   // Soft Delete needs to be applied
   // first for hooks to work correctly.
@@ -63,6 +68,7 @@ export function createSchema(definition, options = {}) {
   applyCache(schema, definition);
   applyClone(schema);
   applyReload(schema);
+  applyExport(schema);
   applyDisallowed(schema);
   applyInclude(schema);
   applyHydrate(schema);
@@ -78,17 +84,9 @@ export function normalizeAttributes(arg, path = []) {
     return arg;
   } else if (typeof arg === 'function') {
     throw new Error('Native functions are not allowed as types.');
-  } else if (typeof arg === 'string') {
-    return normalizeSchemaTypedef({ type: arg }, path);
-  } else if (Array.isArray(arg)) {
-    return normalizeSchemaTypedef({ type: arg }, path);
+  } else if (isTypedefInput(arg)) {
+    return normalizeTypedef(arg, path);
   } else if (typeof arg === 'object') {
-    assertRefs(arg, path);
-
-    if (isSchemaTypedef(arg)) {
-      return normalizeSchemaTypedef(arg, path);
-    }
-
     const attributes = {};
     for (let [key, val] of Object.entries(arg)) {
       attributes[key] = normalizeAttributes(val, [...path, key]);
@@ -97,78 +95,77 @@ export function normalizeAttributes(arg, path = []) {
   }
 }
 
-function normalizeSchemaTypedef(typedef, path) {
-  const { type } = typedef;
+function normalizeArrayAttributes(arr, path) {
+  return arr.map((el, i) => {
+    return normalizeAttributes(el, [...path, i]);
+  });
+}
 
-  if (Array.isArray(type)) {
-    typedef.type = normalizeArrayAttributes(type, path);
-  } else if (typeof type === 'object') {
-    typedef.type = normalizeAttributes(type, path);
-  } else {
-    assertSchemaType(type, path);
+function normalizeTypedef(arg, path) {
+  const typedef = arg.type ? arg : { type: arg };
+
+  if (Array.isArray(typedef.type)) {
+    // Normalize all inner fields.
+    typedef.type = normalizeArrayAttributes(typedef.type, path);
+  } else if (typeof typedef.type === 'object') {
+    // Normalize literal "type" field.
+    typedef.type = normalizeAttributes(typedef.type, path);
+  } else if (isExtendedSyntax(typedef)) {
+    // Normalize extended syntax: type "Object" or "Array".
+    typedef.attributes = normalizeAttributes(typedef.attributes, path);
   }
 
   if (typedef.type === 'String') {
+    // Auto-apply trim to string fields.
     typedef.trim ??= true;
+
+    if (typeof typedef.match === 'string') {
+      // Convert string RegExp so that
+      // it can be expressed in JSON.
+      typedef.match = parseRegExp(typedef.match);
+    }
   }
 
-  return typedef;
-}
+  assertSchemaType(typedef, path);
+  assertObjectRefs(typedef, path);
 
-function normalizeArrayAttributes(arr, path) {
-  return arr.map((el, i) => {
-    return normalizeAttributes(el, [...path, i]);
-  });
+  return typedef;
 }
 
-function attributesToMongoose(attributes) {
-  if (typeof attributes === 'string') {
-    return attributes;
-  } else if (Array.isArray(attributes)) {
-    return attributes.map(attributesToMongoose);
-  }
-
-  attributes = normalizeAttributes(attributes);
-
-  let definition = {};
-
-  const isTypedef = isSchemaTypedef(attributes);
-
-  for (let [key, val] of Object.entries(attributes)) {
-    const type = typeof val;
-    if (isTypedef) {
-      if (key === 'type' && type !== 'function') {
-        val = attributesToMongoose(val);
-      } else if (key === 'match' && type === 'string') {
-        // Convert match field to RegExp that cannot be expressed in JSON.
-        val = parseRegExp(val);
-      } else if (key === 'validate' && type === 'string') {
-        // Allow custom mongoose validation function that derives from the schema.
-        val = getNamedValidator(val);
-      } else if (key === 'attributes' && type === 'object') {
-        val = attributesToMongoose(val);
-      }
-    } else if (Array.isArray(val)) {
-      val = val.map(attributesToMongoose);
-    } else if (isPlainObject(val)) {
-      if (isScopeExtension(val)) {
-        applyScopeExtension(val, definition);
-        continue;
-      } else {
-        val = attributesToMongoose(val);
-      }
-    }
-    definition[key] = val;
+function isTypedefInput(arg) {
+  if (typeof arg === 'string') {
+    // "Number" as shorthand for a typedef.
+    return true;
+  } else if (Array.isArray(arg)) {
+    // Array signals an array field with inner schema.
+    return true;
+  } else if (hasLiteralTypeField(arg)) {
+    // An object with a literal "type" field.
+    return false;
   }
+  return isSchemaTypedef(arg);
+}
 
-  if (isTypedef) {
-    applyExtensions(definition);
+// Detects input like:
+// {
+//   "type": "String",
+//   "name": "String",
+// }
+// Which is not intended to be a typedef.
+function hasLiteralTypeField(arg) {
+  const { type, ...rest } = arg || {};
+
+  if (!isMongooseType(type)) {
+    return false;
   }
 
-  return definition;
+  return Object.values(rest).some((key) => {
+    return isMongooseType(key);
+  });
 }
 
-function assertSchemaType(type, path) {
+function assertSchemaType(typedef, path) {
+  const { type } = typedef;
   if (typeof type === 'string') {
     if (!isMongooseType(type)) {
       const p = path.join('.');
@@ -182,46 +179,68 @@ function assertSchemaType(type, path) {
   }
 }
 
-function assertRefs(field, path) {
-  const { type, ref, refPath } = field;
+function assertObjectRefs(typedef, path) {
+  const { type, ref } = typedef;
   const p = path.join('.');
-  if (isObjectIdType(type) && !ref && !refPath) {
+
+  if (requiresRef(typedef, path)) {
     throw new Error(`Ref must be passed for "${p}".`);
+    // TODO: what is the middle part doing here??
   } else if (ref && !isMongooseType(ref) && !isObjectIdType(type)) {
     throw new Error(`Ref field "${p}" must be type "ObjectId".`);
   }
 }
 
-function camelUpper(str) {
-  return capitalize(camelCase(str));
-}
+function requiresRef(typedef, path) {
+  const { type, ref, refPath } = typedef;
 
-function isObjectIdType(type) {
-  return type === 'ObjectId' || type === mongoose.Schema.Types.ObjectId;
-}
+  // Allow "_id" to not have a ref for the
+  // delete hooks module to function.
+  if (last(path) === '_id') {
+    return false;
+  }
 
-function isMongooseType(type) {
-  return !!mongoose.Schema.Types[type];
+  return isObjectIdType(type) && !ref && !refPath;
 }
 
-function applyExtensions(typedef) {
-  applySyntaxExtensions(typedef);
-  applyUniqueExtension(typedef);
-  applyTupleExtension(typedef);
-  applyDateExtension(typedef);
+// Extensions
+
+function applyExtensions(arg) {
+  if (isSchemaTypedef(arg)) {
+    applySyntaxExtensions(arg);
+    applyValidateExtension(arg);
+    applyUniqueExtension(arg);
+    applyTupleExtension(arg);
+    applyDateExtension(arg);
+
+    if (Array.isArray(arg.type)) {
+      for (let field of arg.type) {
+        applyExtensions(field);
+      }
+      applyArrayValidators(arg);
+      applyOptionHoisting(arg);
+    }
+  } else if (isPlainObject(arg)) {
+    for (let [key, value] of Object.entries(arg)) {
+      if (isScopeExtension(value)) {
+        applyScopeExtension(value, arg, key);
+      } else {
+        applyExtensions(value);
+      }
+    }
+  }
 }
 
 function applySyntaxExtensions(typedef) {
   const { type, attributes } = typedef;
   if (isExtendedSyntax(typedef)) {
-    typedef.type = new mongoose.Schema(attributes);
+    applyExtensions(attributes);
     if (type === 'Array') {
-      typedef.type = [typedef.type];
+      typedef.type = [attributes];
+    } else if (type === 'Object') {
+      typedef.type = new mongoose.Schema(attributes);
     }
-  }
-  if (Array.isArray(typedef.type)) {
-    applyArrayValidators(typedef);
-    applyOptionHoisting(typedef);
+    delete typedef['attributes'];
   }
 }
 
@@ -233,30 +252,42 @@ function applyOptionHoisting(typedef) {
 
 function isExtendedSyntax(typedef) {
   const { type, attributes } = typedef;
-  return attributes && (type === 'Object' || type === 'Array');
+  if (!attributes) {
+    return false;
+  }
+  return type === 'Object' || type === 'Array' || type === 'Scope';
 }
 
 function isScopeExtension(arg) {
   return isSchemaTypedef(arg) && arg.type === 'Scope';
 }
 
-function applyScopeExtension(typedef, definition) {
-  const { type, attributes, ...options } = typedef;
-  for (let [key, val] of Object.entries(normalizeAttributes(attributes))) {
-    if (isSchemaTypedef(val)) {
-      val = {
-        ...val,
-        ...options,
+function applyScopeExtension(typedef, parent, name) {
+  const { type, attributes, ...rest } = typedef;
+
+  for (let [key, value] of Object.entries(attributes)) {
+    if (isSchemaTypedef(value)) {
+      // If the child is a typedef then apply
+      // options directly to the field.
+      applyExtensions(value);
+      parent[key] = {
+        ...value,
+        ...rest,
       };
     } else {
-      val = {
+      // If the child is a nested object then
+      // need to use extended object syntax.
+      const typedef = {
         type: 'Object',
-        attributes: val,
-        ...options,
+        attributes: value,
+        ...rest,
       };
+      applyExtensions(typedef);
+      parent[key] = typedef;
     }
-    definition[key] = attributesToMongoose(val);
   }
+
+  delete parent[name];
 }
 
 // Extended tuple syntax. Return mixed type and set validator.
@@ -284,6 +315,15 @@ function applyDateExtension(typedef) {
   }
 }
 
+// Apply custom mongoose validation by name.
+function applyValidateExtension(typedef) {
+  const { validate } = typedef;
+
+  if (typeof validate === 'string') {
+    typedef.validate = getNamedValidator(typedef.validate);
+  }
+}
+
 // Intercepts "unique" options and changes to "softUnique".
 function applyUniqueExtension(typedef) {
   if (typedef.unique === true) {
@@ -323,12 +363,7 @@ function validateMaxLength(max) {
   };
 }
 
-function chain(fn1, fn2) {
-  return (...args) => {
-    fn1?.(...args);
-    fn2?.(...args);
-  };
-}
+// Regex Parsing
 
 const REG_MATCH = /^\/(.+)\/(\w+)$/;
 
@@ -340,3 +375,24 @@ function parseRegExp(str) {
   const [, source, flags] = match;
   return RegExp(source, flags);
 }
+
+// Utils
+
+function camelUpper(str) {
+  return capitalize(camelCase(str));
+}
+
+function isObjectIdType(type) {
+  return type === 'ObjectId' || type === mongoose.Schema.Types.ObjectId;
+}
+
+function isMongooseType(type) {
+  return !!mongoose.Schema.Types[type];
+}
+
+function chain(fn1, fn2) {
+  return (...args) => {
+    fn1?.(...args);
+    fn2?.(...args);
+  };
+}

package/types/cache.d.ts

@@ -1,2 +1,3 @@
+export function addCacheFields(definition: any): void;
 export function applyCache(schema: any, definition: any): void;
 //# sourceMappingURL=cache.d.ts.map

package/types/cache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../src/cache.js"],"names":[],"mappings":"AASA,+DAUC"}
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../src/cache.js"],"names":[],"mappings":"AASA,sDAeC;AAED,+DASC"}

package/types/delete-hooks.d.ts

@@ -1,2 +1,3 @@
+export function addDeletedFields(definition: any): void;
 export function applyDeleteHooks(schema: any, definition: any): void;
 //# sourceMappingURL=delete-hooks.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"delete-hooks.d.ts","sourceRoot":"","sources":["../src/delete-hooks.js"],"names":[],"mappings":"AAQA,qEA8CC"}
+{"version":3,"file":"delete-hooks.d.ts","sourceRoot":"","sources":["../src/delete-hooks.js"],"names":[],"mappings":"AAQA,wDAaC;AAED,qEAqCC"}

package/types/export.d.ts

@@ -0,0 +1,2 @@
+export function applyExport(schema: any): void;
+//# sourceMappingURL=export.d.ts.map

package/types/export.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"export.d.ts","sourceRoot":"","sources":["../src/export.js"],"names":[],"mappings":"AAEA,+CAWC"}

package/types/reload.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reload.d.ts","sourceRoot":"","sources":["../src/reload.js"],"names":[],"mappings":"AAKA,+CAWC"}
+{"version":3,"file":"reload.d.ts","sourceRoot":"","sources":["../src/reload.js"],"names":[],"mappings":"AAKA,+CAwBC"}

package/types/schema.d.ts

@@ -19,7 +19,6 @@ export function createSchema(definition: object, options?: mongoose.SchemaOption
     };
     collation?: mongoose.mongo.CollationOptions;
     collectionOptions?: mongoose.mongo.CreateCollectionOptions;
-    lean?: boolean | mongoose.LeanOptions;
     timeseries?: mongoose.mongo.TimeSeriesCollectionOptions;
     expireAfterSeconds?: number;
     expires?: number | string;

package/types/schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.js"],"names":[],"mappings":"AAwBA;;;;;;;GAOG;AACH,yCAJW,MAAM,YACN,QAAQ,CAAC,aAAa;;;;;;;YA+CX,CAAC;WAAa,CAAC;mBAEnC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;SA4HmB,CAAC;gBACL,CAAC;SAAW,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAlI9B;AAED,iEAsBC;qBAhGoB,UAAU"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.js"],"names":[],"mappings":"AAyBA;;;;;;;GAOG;AACH,yCAJW,MAAM,YACN,QAAQ,CAAC,aAAa;;;;;;;YA2C7B,CAAC;WAAa,CAAC;mBACH,CAAC;;;;;;;;;;;;;;;;;;;;;;;SAgIb,CAAC;gBAA4B,CAAA;SAAW,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aA3H5C;AAED,iEAcC;qBA9FoB,UAAU"}