@bedrockio/model 0.18.1 → 0.18.2

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 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.

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/schema.js

@@ -33,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,
@@ -45,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,
@@ -75,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]);
@@ -95,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('.');
@@ -169,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 {
@@ -203,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'];
   }
 }
 
@@ -224,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.
@@ -281,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) {
@@ -320,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);
@@ -334,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.1",
+  "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/schema.js

@@ -1,10 +1,10 @@
-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';
@@ -32,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.
@@ -80,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]);
@@ -99,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('.');
@@ -184,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'];
   }
 }
 
@@ -235,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.
@@ -286,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) {
@@ -325,12 +363,7 @@ function validateMaxLength(max) {
   };
 }
 
-function chain(fn1, fn2) {
-  return (...args) => {
-    fn1?.(...args);
-    fn2?.(...args);
-  };
-}
+// Regex Parsing
 
 const REG_MATCH = /^\/(.+)\/(\w+)$/;
 
@@ -342,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/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":"AAyBA;;;;;;;GAOG;AACH,yCAJW,MAAM,YACN,QAAQ,CAAC,aAAa;;;;;;;YA+CpB,CAAC;WAAa,CAAC;mBAAqB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;SA4Hf,CAAC;gBAA2B,CAAC;SAGhE,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAjIC;AAED,iEAsBC;qBAlGoB,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"}