@bedrockio/model 0.13.3 → 0.14.1

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+## 0.14.1
+
+- Ensure includes are allowed on `getUpdateValidattion`.
+
+## 0.14.0
+
+- More clearly defined assign behavior on nested fields.
+- Flat syntax will be equivalent to PATCH behavior.
+- Nested syntax will be equivalent to PUT behavior.
+- Both types are consistent across objects and arrays.
+- Version bumps.
+
 ## 0.13.3
 
 - Bumped yada version.

package/dist/cjs/assign.js

@@ -5,62 +5,31 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.applyAssign = applyAssign;
 var _lodash = require("lodash");
-var _mongoose = _interopRequireDefault(require("mongoose"));
-var _utils = require("./utils");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 function applyAssign(schema) {
   schema.method('assign', function assign(fields) {
-    unsetReferenceFields(fields, schema.obj);
-    for (let [path, value] of Object.entries(flattenObject(fields))) {
-      if (value === null || value === '') {
-        this.set(path, undefined);
-      } else {
-        this.set(path, value);
-      }
-    }
+    fields = unsetFalsyValues(fields);
+    this.set(fields);
   });
 }
 
-// Sets falsy reference fields to undefined to signal
-// removal. Passing attributes through this function
-// normalizes falsy values so they are not saved to the db.
-function unsetReferenceFields(fields, schema = {}) {
-  for (let [key, value] of Object.entries(fields)) {
-    if (!value && (0, _utils.isReferenceField)(schema, key)) {
-      fields[key] = undefined;
-    } else if (value instanceof _mongoose.default.Document) {
-      fields[key] = value;
-    } else if (hasEnumerableFields(value)) {
-      unsetReferenceFields(value, (0, _utils.getField)(schema, key));
-    }
-  }
-}
-
-// Flattens nested objects to a dot syntax.
-// Effectively the inverse of lodash get:
-// { foo: { bar: 3 } } -> { 'foo.bar': 3 }
-function flattenObject(obj, root = {}, rootPath = []) {
-  for (let [key, val] of Object.entries(obj)) {
-    const path = [...rootPath, key];
-    if (hasEnumerableFields(val)) {
-      flattenObject(val, root, path);
-    } else {
-      root[path.join('.')] = val;
+// Force falsy fields to undefined to unset then instead of
+// saving to the db (null, empty string, etc).
+// Note that as of version 8.18.2 Mongoose will still happily
+// set `null` or empty string directly in the db. However note
+// that in mongodb querying on `null` will match both `null` and
+// unset fields.
+function unsetFalsyValues(arg) {
+  if ((0, _lodash.isPlainObject)(arg)) {
+    const result = {};
+    for (let [key, value] of Object.entries(arg)) {
+      result[key] = unsetFalsyValues(value);
     }
+    return result;
+  } else if (Array.isArray(arg)) {
+    return arg.map(unsetFalsyValues);
+  } else if (arg === '' || arg === null) {
+    return undefined;
+  } else {
+    return arg;
   }
-  return root;
-}
-
-// Only plain objects and arrays with fields should
-// be enumerated to allow setting of their inner fields.
-// Note that mongoose documents etc should NOT be enumerated
-// over as their value should be set directly for the field.
-// Additionally if an array is empty it should not have its
-// fields enumerated but instead directly set the empty array
-// for the field.
-function hasEnumerableFields(arg) {
-  if ((0, _lodash.isPlainObject)(arg) || Array.isArray(arg)) {
-    return Object.keys(arg).length > 0;
-  }
-  return false;
 }

package/dist/cjs/cache.js

@@ -4,8 +4,8 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.applyCache = applyCache;
-var _mongoose = _interopRequireDefault(require("mongoose"));
 var _lodash = require("lodash");
+var _mongoose = _interopRequireDefault(require("mongoose"));
 var _utils = require("./utils");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 const definitionMap = new Map();

package/dist/cjs/delete-hooks.js

@@ -4,8 +4,8 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.applyDeleteHooks = applyDeleteHooks;
-var _mongoose = _interopRequireDefault(require("mongoose"));
 var _lodash = require("lodash");
+var _mongoose = _interopRequireDefault(require("mongoose"));
 var _errors = require("./errors");
 var _utils = require("./utils");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }

package/dist/cjs/include.js

@@ -8,11 +8,11 @@ exports.applyInclude = applyInclude;
 exports.checkSelects = checkSelects;
 exports.getDocumentParams = getDocumentParams;
 exports.getParams = getParams;
-var _mongoose = _interopRequireDefault(require("mongoose"));
-var _lodash = require("lodash");
 var _yada = _interopRequireDefault(require("@bedrockio/yada"));
-var _utils = require("./utils");
+var _lodash = require("lodash");
+var _mongoose = _interopRequireDefault(require("mongoose"));
 var _const = require("./const");
+var _utils = require("./utils");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 // @ts-ignore
 // Overloading mongoose Query prototype to

package/dist/cjs/load.js

@@ -7,8 +7,8 @@ exports.loadModel = loadModel;
 exports.loadModelDir = loadModelDir;
 var _fs = _interopRequireDefault(require("fs"));
 var _path = _interopRequireDefault(require("path"));
-var _mongoose = _interopRequireDefault(require("mongoose"));
 var _lodash = require("lodash");
+var _mongoose = _interopRequireDefault(require("mongoose"));
 var _schema = require("./schema");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 /**

package/dist/cjs/schema.js

@@ -5,21 +5,21 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.createSchema = createSchema;
 exports.normalizeAttributes = normalizeAttributes;
-var _mongoose = _interopRequireDefault(require("mongoose"));
 var _lodash = require("lodash");
-var _utils = require("./utils");
-var _serialization = require("./serialization");
-var _slug = require("./slug");
+var _mongoose = _interopRequireDefault(require("mongoose"));
+var _assign = require("./assign");
 var _cache = require("./cache");
 var _clone = require("./clone");
-var _search = require("./search");
-var _assign = require("./assign");
-var _upsert = require("./upsert");
+var _deleteHooks = require("./delete-hooks");
+var _disallowed = require("./disallowed");
 var _hydrate = require("./hydrate");
 var _include = require("./include");
+var _search = require("./search");
+var _serialization = require("./serialization");
+var _slug = require("./slug");
 var _softDelete = require("./soft-delete");
-var _deleteHooks = require("./delete-hooks");
-var _disallowed = require("./disallowed");
+var _upsert = require("./upsert");
+var _utils = require("./utils");
 var _validation = require("./validation");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 /**

package/dist/cjs/search.js

@@ -6,15 +6,15 @@ Object.defineProperty(exports, "__esModule", {
 exports.applySearch = applySearch;
 exports.exportValidation = exportValidation;
 exports.searchValidation = searchValidation;
-var _yada = _interopRequireDefault(require("@bedrockio/yada"));
 var _logger = _interopRequireDefault(require("@bedrockio/logger"));
-var _mongoose = _interopRequireDefault(require("mongoose"));
+var _yada = _interopRequireDefault(require("@bedrockio/yada"));
 var _lodash = require("lodash");
-var _utils = require("./utils");
+var _mongoose = _interopRequireDefault(require("mongoose"));
 var _const = require("./const");
-var _validationSchemas = require("./validation-schemas");
 var _env = require("./env");
 var _query = require("./query");
+var _utils = require("./utils");
+var _validationSchemas = require("./validation-schemas");
 var _warn = _interopRequireDefault(require("./warn"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 const {

package/dist/cjs/serialization.js

@@ -5,9 +5,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.serializeOptions = void 0;
 var _lodash = require("lodash");
+var _access = require("./access");
 var _include = require("./include");
 var _utils = require("./utils");
-var _access = require("./access");
 const DISALLOWED_FIELDS = ['deleted', 'deletedRefs'];
 const serializeOptions = exports.serializeOptions = {
   getters: true,

package/dist/cjs/soft-delete.js

@@ -6,9 +6,9 @@ Object.defineProperty(exports, "__esModule", {
 exports.applySoftDelete = applySoftDelete;
 exports.assertUnique = assertUnique;
 var _lodash = require("lodash");
-var _warn = _interopRequireDefault(require("./warn"));
-var _query = require("./query");
 var _errors = require("./errors");
+var _query = require("./query");
+var _warn = _interopRequireDefault(require("./warn"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 function applySoftDelete(schema) {
   applyQueries(schema);

package/dist/cjs/validation.js

@@ -8,15 +8,15 @@ exports.applyValidation = applyValidation;
 exports.getNamedValidator = getNamedValidator;
 exports.getTupleValidator = getTupleValidator;
 exports.getValidationSchema = getValidationSchema;
-var _mongoose = _interopRequireDefault(require("mongoose"));
 var _yada = _interopRequireDefault(require("@bedrockio/yada"));
 var _lodash = require("lodash");
+var _mongoose = _interopRequireDefault(require("mongoose"));
 var _access = require("./access");
+var _errors = require("./errors");
+var _include = require("./include");
 var _search = require("./search");
 var _softDelete = require("./soft-delete");
-var _errors = require("./errors");
 var _utils = require("./utils");
-var _include = require("./include");
 var _validationSchemas = require("./validation-schemas");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 const NAMED_SCHEMAS = {
@@ -80,7 +80,8 @@ function applyValidation(schema, definition) {
       skipRequired: true,
       stripUnknown: true,
       stripDeleted: true,
-      allowInclude: false,
+      allowFlatKeys: true,
+      allowInclude: true,
       stripTimestamps: true,
       allowExpandedRefs: true,
       requireWriteAccess: true,
@@ -103,6 +104,7 @@ function applyValidation(schema, definition) {
       skipRequired: true,
       allowInclude: true,
       stripDeleted: true,
+      allowFlatKeys: true,
       unwindArrayFields: true,
       requireReadAccess: true,
       ...rest
@@ -187,7 +189,8 @@ function getObjectSchema(arg, options) {
   } else if (typeof arg === 'object') {
     const {
       stripUnknown,
-      stripEmpty
+      stripEmpty,
+      allowFlatKeys
     } = options;
     const map = {};
     for (let [key, field] of Object.entries(arg)) {
@@ -206,6 +209,11 @@ function getObjectSchema(arg, options) {
         stripEmpty: true
       });
     }
+    if (allowFlatKeys) {
+      schema = schema.options({
+        allowFlatKeys: true
+      });
+    }
     return schema;
   } else {
     return getSchemaForType(arg, options);

package/eslint.config.js

@@ -1,2 +1,2 @@
-import { jest, recommended, nodeImports } from '@bedrockio/eslint-plugin';
+import { jest, nodeImports, recommended } from '@bedrockio/eslint-plugin';
 export default [jest, recommended, nodeImports];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bedrockio/model",
-  "version": "0.13.3",
+  "version": "0.14.1",
   "description": "Bedrock utilities for model creation.",
   "type": "module",
   "scripts": {
@@ -30,24 +30,24 @@
     "lodash": "^4.17.21"
   },
   "peerDependencies": {
-    "@bedrockio/yada": "^1.6.1",
-    "mongoose": "^8.13.1"
+    "@bedrockio/yada": "^1.8.0",
+    "mongoose": "^8.18.2"
   },
   "devDependencies": {
     "@babel/cli": "^7.26.4",
     "@babel/core": "^7.26.0",
     "@babel/preset-env": "^7.26.0",
-    "@bedrockio/eslint-plugin": "^1.1.7",
-    "@bedrockio/prettier-config": "^1.0.2",
-    "@bedrockio/yada": "^1.6.1",
-    "@shelf/jest-mongodb": "^5.1.0",
-    "eslint": "^9.19.0",
-    "jest": "^29.7.0",
-    "jest-environment-node": "^29.7.0",
-    "mongodb": "^6.15.0",
-    "mongoose": "^8.13.1",
-    "prettier": "^3.4.2",
-    "typescript": "^5.7.2"
+    "@bedrockio/eslint-plugin": "^1.2.2",
+    "@bedrockio/prettier-config": "^1.1.1",
+    "@bedrockio/yada": "^1.8.0",
+    "@shelf/jest-mongodb": "^5.2.2",
+    "eslint": "^9.36.0",
+    "jest": "^30.2.0",
+    "jest-environment-node": "^30.2.0",
+    "mongodb": "^6.20.0",
+    "mongoose": "^8.18.2",
+    "prettier": "^3.6.2",
+    "typescript": "^5.9.2"
   },
   "prettier": "@bedrockio/prettier-config",
   "volta": {

package/src/assign.js

@@ -1,61 +1,30 @@
 import { isPlainObject } from 'lodash';
-import mongoose from 'mongoose';
-
-import { isReferenceField, getField } from './utils';
 
 export function applyAssign(schema) {
   schema.method('assign', function assign(fields) {
-    unsetReferenceFields(fields, schema.obj);
-    for (let [path, value] of Object.entries(flattenObject(fields))) {
-      if (value === null || value === '') {
-        this.set(path, undefined);
-      } else {
-        this.set(path, value);
-      }
-    }
+    fields = unsetFalsyValues(fields);
+    this.set(fields);
   });
 }
 
-// Sets falsy reference fields to undefined to signal
-// removal. Passing attributes through this function
-// normalizes falsy values so they are not saved to the db.
-function unsetReferenceFields(fields, schema = {}) {
-  for (let [key, value] of Object.entries(fields)) {
-    if (!value && isReferenceField(schema, key)) {
-      fields[key] = undefined;
-    } else if (value instanceof mongoose.Document) {
-      fields[key] = value;
-    } else if (hasEnumerableFields(value)) {
-      unsetReferenceFields(value, getField(schema, key));
+// Force falsy fields to undefined to unset then instead of
+// saving to the db (null, empty string, etc).
+// Note that as of version 8.18.2 Mongoose will still happily
+// set `null` or empty string directly in the db. However note
+// that in mongodb querying on `null` will match both `null` and
+// unset fields.
+function unsetFalsyValues(arg) {
+  if (isPlainObject(arg)) {
+    const result = {};
+    for (let [key, value] of Object.entries(arg)) {
+      result[key] = unsetFalsyValues(value);
     }
+    return result;
+  } else if (Array.isArray(arg)) {
+    return arg.map(unsetFalsyValues);
+  } else if (arg === '' || arg === null) {
+    return undefined;
+  } else {
+    return arg;
   }
 }
-
-// Flattens nested objects to a dot syntax.
-// Effectively the inverse of lodash get:
-// { foo: { bar: 3 } } -> { 'foo.bar': 3 }
-function flattenObject(obj, root = {}, rootPath = []) {
-  for (let [key, val] of Object.entries(obj)) {
-    const path = [...rootPath, key];
-    if (hasEnumerableFields(val)) {
-      flattenObject(val, root, path);
-    } else {
-      root[path.join('.')] = val;
-    }
-  }
-  return root;
-}
-
-// Only plain objects and arrays with fields should
-// be enumerated to allow setting of their inner fields.
-// Note that mongoose documents etc should NOT be enumerated
-// over as their value should be set directly for the field.
-// Additionally if an array is empty it should not have its
-// fields enumerated but instead directly set the empty array
-// for the field.
-function hasEnumerableFields(arg) {
-  if (isPlainObject(arg) || Array.isArray(arg)) {
-    return Object.keys(arg).length > 0;
-  }
-  return false;
-}

package/src/cache.js

@@ -1,5 +1,5 @@
+import { get, groupBy, once } from 'lodash';
 import mongoose from 'mongoose';
-import { get, once, groupBy } from 'lodash';
 
 import { resolveRefPath } from './utils';
 

package/src/delete-hooks.js

@@ -1,5 +1,5 @@
-import mongoose from 'mongoose';
 import { groupBy } from 'lodash';
+import mongoose from 'mongoose';
 
 import { ReferenceError } from './errors';
 import { getInnerField } from './utils';

package/src/include.js

@@ -1,9 +1,9 @@
-import mongoose from 'mongoose';
-import { escapeRegExp } from 'lodash';
 import yd from '@bedrockio/yada';
+import { escapeRegExp } from 'lodash';
+import mongoose from 'mongoose';
 
-import { getInnerField, isSchemaTypedef } from './utils';
 import { POPULATE_MAX_DEPTH } from './const';
+import { getInnerField, isSchemaTypedef } from './utils';
 
 // @ts-ignore
 // Overloading mongoose Query prototype to

package/src/load.js

@@ -1,8 +1,8 @@
 import fs from 'fs';
 import path from 'path';
 
-import mongoose from 'mongoose';
 import { startCase } from 'lodash';
+import mongoose from 'mongoose';
 
 import { createSchema } from './schema';
 

package/src/schema.js

@@ -1,20 +1,19 @@
+import { camelCase, capitalize, isPlainObject, pick } from 'lodash';
 import mongoose from 'mongoose';
-import { pick, isPlainObject, capitalize, camelCase } from 'lodash';
 
-import { isSchemaTypedef } from './utils';
-
-import { serializeOptions } from './serialization';
-import { applySlug } from './slug';
+import { applyAssign } from './assign';
 import { applyCache } from './cache';
 import { applyClone } from './clone';
-import { applySearch } from './search';
-import { applyAssign } from './assign';
-import { applyUpsert } from './upsert';
+import { applyDeleteHooks } from './delete-hooks';
+import { applyDisallowed } from './disallowed';
 import { applyHydrate } from './hydrate';
 import { applyInclude } from './include';
+import { applySearch } from './search';
+import { serializeOptions } from './serialization';
+import { applySlug } from './slug';
 import { applySoftDelete } from './soft-delete';
-import { applyDeleteHooks } from './delete-hooks';
-import { applyDisallowed } from './disallowed';
+import { applyUpsert } from './upsert';
+import { isSchemaTypedef } from './utils';
 
 import {
   applyValidation,

package/src/search.js

@@ -1,7 +1,11 @@
-import yd from '@bedrockio/yada';
 import logger from '@bedrockio/logger';
+import yd from '@bedrockio/yada';
+import { escapeRegExp, isEmpty, isPlainObject, memoize, pick } from 'lodash';
 import mongoose from 'mongoose';
-import { pick, isEmpty, memoize, escapeRegExp, isPlainObject } from 'lodash';
+
+import { SEARCH_DEFAULTS } from './const';
+import { debug } from './env';
+import { mergeQuery, wrapQuery } from './query';
 
 import {
   getField,
@@ -12,11 +16,7 @@ import {
   resolveRefPath,
 } from './utils';
 
-import { SEARCH_DEFAULTS } from './const';
 import { OBJECT_ID_SCHEMA } from './validation-schemas';
-import { debug } from './env';
-import { mergeQuery, wrapQuery } from './query';
-
 import warn from './warn';
 
 const { ObjectId } = mongoose.Types;

package/src/serialization.js

@@ -1,8 +1,8 @@
 import { isPlainObject } from 'lodash';
 
+import { hasAccess } from './access';
 import { checkSelects } from './include';
 import { getField, getInnerField } from './utils';
-import { hasAccess } from './access';
 
 const DISALLOWED_FIELDS = ['deleted', 'deletedRefs'];
 

package/src/soft-delete.js

@@ -1,9 +1,8 @@
 import { isEqual } from 'lodash';
 
-import warn from './warn';
-
-import { wrapQuery } from './query';
 import { UniqueConstraintError } from './errors';
+import { wrapQuery } from './query';
+import warn from './warn';
 
 export function applySoftDelete(schema) {
   applyQueries(schema);

package/src/validation.js

@@ -1,21 +1,21 @@
-import mongoose from 'mongoose';
 import yd from '@bedrockio/yada';
-
-import { get, omit, lowerFirst } from 'lodash';
+import { get, lowerFirst, omit } from 'lodash';
+import mongoose from 'mongoose';
 
 import { hasAccess } from './access';
-import { searchValidation, exportValidation } from './search';
+import { ImplementationError, PermissionsError } from './errors';
+import { INCLUDE_FIELD_SCHEMA } from './include';
+import { exportValidation, searchValidation } from './search';
 import { assertUnique } from './soft-delete';
-import { PermissionsError, ImplementationError } from './errors';
 import { isMongooseSchema, isSchemaTypedef } from './utils';
-import { INCLUDE_FIELD_SCHEMA } from './include';
+
 import {
+  DATE_RANGE_SCHEMA,
   DATE_SCHEMA,
-  REFERENCE_SCHEMA,
-  OBJECT_ID_SCHEMA,
   NUMBER_RANGE_SCHEMA,
+  OBJECT_ID_SCHEMA,
+  REFERENCE_SCHEMA,
   STRING_RANGE_SCHEMA,
-  DATE_RANGE_SCHEMA,
 } from './validation-schemas';
 
 const NAMED_SCHEMAS = {
@@ -84,7 +84,8 @@ export function applyValidation(schema, definition) {
       skipRequired: true,
       stripUnknown: true,
       stripDeleted: true,
-      allowInclude: false,
+      allowFlatKeys: true,
+      allowInclude: true,
       stripTimestamps: true,
       allowExpandedRefs: true,
       requireWriteAccess: true,
@@ -106,6 +107,7 @@ export function applyValidation(schema, definition) {
         skipRequired: true,
         allowInclude: true,
         stripDeleted: true,
+        allowFlatKeys: true,
         unwindArrayFields: true,
         requireReadAccess: true,
         ...rest,
@@ -199,7 +201,7 @@ function getObjectSchema(arg, options) {
   } else if (Array.isArray(arg)) {
     return getArraySchema(arg, options);
   } else if (typeof arg === 'object') {
-    const { stripUnknown, stripEmpty } = options;
+    const { stripUnknown, stripEmpty, allowFlatKeys } = options;
     const map = {};
     for (let [key, field] of Object.entries(arg)) {
       if (!isExcludedField(field, options)) {
@@ -221,6 +223,12 @@ function getObjectSchema(arg, options) {
       });
     }
 
+    if (allowFlatKeys) {
+      schema = schema.options({
+        allowFlatKeys: true,
+      });
+    }
+
     return schema;
   } else {
     return getSchemaForType(arg, options);

package/types/assign.d.ts.map

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

package/types/include.d.ts

@@ -9,12 +9,15 @@ export const INCLUDE_FIELD_SCHEMA: {
     pick(...names?: string[]): /*elided*/ any;
     omit(...names?: string[]): /*elided*/ any;
     require(...fields: string[]): /*elided*/ any;
+    requireAll(): /*elided*/ any;
+    requireAllWithin(): /*elided*/ any;
     export(): any;
     append(arg: import("@bedrockio/yada/types/object").SchemaMap | import("@bedrockio/yada/types/Schema").default): /*elided*/ any;
     options(options?: {
         stripEmpty?: boolean;
         stripUnknown?: boolean;
-        preserveKeys?: boolean;
+        allowFlatKeys?: boolean;
+        expandFlatKeys?: boolean;
     }): /*elided*/ any;
     format(name: any, fn: any): /*elided*/ any;
     toString(): any;
@@ -38,6 +41,9 @@ export const INCLUDE_FIELD_SCHEMA: {
     getAnyType(): {
         type: string[];
     };
+    getFormat(): {
+        format: any;
+    };
     getDefault(): {
         default?: undefined;
     } | {

package/types/include.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"include.d.ts","sourceRoot":"","sources":["../src/include.js"],"names":[],"mappings":"AA2BA,gDAuEC;AAMD,uDA4BC;AAGD,yDAIC;AAaD,yEAUC;AA9ID;;;;;;;;;;kBAyFsB,CAAC;oBACD,CAAC;oBACE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;eApBT,CAAC;;;;;;;;;;;;;;;;;EAlEf"}
+{"version":3,"file":"include.d.ts","sourceRoot":"","sources":["../src/include.js"],"names":[],"mappings":"AA2BA,gDAuEC;AAMD,uDA4BC;AAGD,yDAIC;AAaD,yEAUC;AA9ID;;;;;;;;;;;;kBAwGwB,CAAC;oBAEnB,CADL;qBAAgC,CAAC;sBACxB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAnCqD,CAAC;;;;;;;;;;;;;;;;;EAlE9D"}

package/types/load.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"load.d.ts","sourceRoot":"","sources":["../src/load.js"],"names":[],"mappings":"AAQA;;;;;GAKG;AACH,sCAJW,MAAM,QACN,MAAM,OAahB;AAED;;;;GAIG;AACH,sCAFW,MAAM,mBAkBhB;qBA5CoB,UAAU"}
+{"version":3,"file":"load.d.ts","sourceRoot":"","sources":["../src/load.js"],"names":[],"mappings":"AAQA;;;;;GAKG;AACH,sCAJW,MAAM,QACN,MAAM,OAahB;AAED;;;;GAIG;AACH,sCAFW,MAAM,mBAkBhB;qBA3CoB,UAAU"}

package/types/schema.d.ts

@@ -28,7 +28,9 @@ export function createSchema(definition: object, options?: mongoose.SchemaOption
     id?: boolean;
     _id?: boolean;
     minimize?: boolean;
-    optimisticConcurrency?: boolean;
+    optimisticConcurrency?: boolean | string[] | {
+        exclude: string[];
+    };
     pluginTags?: string[];
     read?: string;
     readConcern?: {
@@ -47,16 +49,16 @@ export function createSchema(definition: object, options?: mongoose.SchemaOption
         getters: boolean;
         versionKey: boolean;
         transform: (doc: any, ret: any, options: any) => void;
-    } | mongoose.ToObjectOptions<any>;
+    } | mongoose.ToObjectOptions<any, any>;
     toObject: {
         getters: boolean;
         versionKey: boolean;
         transform: (doc: any, ret: any, options: any) => void;
-    } | mongoose.ToObjectOptions<any>;
+    } | mongoose.ToObjectOptions<any, any>;
     typeKey?: string;
     validateBeforeSave?: boolean;
     validateModifiedOnly?: boolean;
-    versionKey?: string | boolean;
+    versionKey?: string | false;
     selectPopulatedPaths?: boolean;
     skipVersioning?: {
         [key: string]: boolean;
@@ -64,12 +66,13 @@ export function createSchema(definition: object, options?: mongoose.SchemaOption
     storeSubdocValidationError?: boolean;
     timestamps: boolean | mongoose.SchemaTimestampsConfig;
     suppressReservedKeysWarning?: boolean;
-    statics?: mongoose.AddThisParameter<any, mongoose.Model<any, {}, {}, {}, any, any>>;
+    statics?: mongoose.AddThisParameter<any, mongoose.Model<any, any, any, any, any, any>>;
     methods?: mongoose.AddThisParameter<any, any> & mongoose.AnyObject;
     query?: any;
     castNonArrays?: boolean;
     virtuals?: mongoose.SchemaOptionsVirtualsPropertyType<any, any, any>;
     overwriteModels?: boolean;
+    encryptionType?: "csfle" | "queryableEncryption";
 }, any, any>;
 export function normalizeAttributes(arg: any, path?: any[]): any;
 import mongoose from 'mongoose';

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;;;;;;;YA6CM,CAAC;WACtC,CAAF;mBAAqB,CAAC;;;;;;;;;;;;;;;;;;;;;SAiHV,CAAA;gBAA2B,CAAC;SAAW,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aApHnD;AAED,iEAsBC;qBAhGoB,UAAU"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.js"],"names":[],"mappings":"AAuBA;;;;;;;GAOG;AACH,yCAJW,MAAM,YACN,QAAQ,CAAC,aAAa;;;;;;;YAgDJ,CAAC;WAC1B,CAAF;mBAAqB,CAAC;;;;;;;;;;;;;;;;;;;;;;;SA2HlB,CAAC;gBACL,CAAC;SAAW,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAlId;AAED,iEAsBC;qBA9FoB,UAAU"}

package/types/search.d.ts

@@ -6,12 +6,15 @@ export function searchValidation(options?: {}): {
     pick(...names?: string[]): /*elided*/ any;
     omit(...names?: string[]): /*elided*/ any;
     require(...fields: string[]): /*elided*/ any;
+    requireAll(): /*elided*/ any;
+    requireAllWithin(): /*elided*/ any;
     export(): any;
     append(arg: import("@bedrockio/yada/types/object").SchemaMap | import("@bedrockio/yada/types/Schema").default): /*elided*/ any;
     options(options?: {
         stripEmpty?: boolean;
         stripUnknown?: boolean;
-        preserveKeys?: boolean;
+        allowFlatKeys?: boolean;
+        expandFlatKeys?: boolean;
     }): /*elided*/ any;
     format(name: any, fn: any): /*elided*/ any;
     toString(): any;
@@ -35,6 +38,9 @@ export function searchValidation(options?: {}): {
     getAnyType(): {
         type: string[];
     };
+    getFormat(): {
+        format: any;
+    };
     getDefault(): {
         default?: undefined;
     } | {
@@ -137,6 +143,9 @@ export function exportValidation(options?: {}): {
         getAnyType(): {
             type: string[];
         };
+        getFormat(): {
+            format: any;
+        };
         getDefault(): {
             default?: undefined;
         } | {
@@ -146,6 +155,7 @@ export function exportValidation(options?: {}): {
             nullable: boolean;
         };
         getEnum(): any;
+        requireAllWithin(): /*elided*/ any;
         expandExtra(extra?: {}): {};
         inspect(): string;
         get(): void;
@@ -239,6 +249,9 @@ export function exportValidation(options?: {}): {
         getAnyType(): {
             type: string[];
         };
+        getFormat(): {
+            format: any;
+        };
         getDefault(): {
             default?: undefined;
         } | {
@@ -248,6 +261,7 @@ export function exportValidation(options?: {}): {
             nullable: boolean;
         };
         getEnum(): any;
+        requireAllWithin(): /*elided*/ any;
         expandExtra(extra?: {}): {};
         inspect(): string;
         get(): void;

package/types/search.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../src/search.js"],"names":[],"mappings":"AAuBA,gEAaC;AAED;;;;;;;;;;kBA0Fe,CAAC;oBAA+B,CAAC;oBAEtB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;eAhCvB,CAAF;;;;;;;;;;;;;;;;;EAnCD;AAED;;;;;;;;;;;;;;;;;mBAtBI,CAAA;;;;;;;;;;;;qBAuBC,CAAC;sBAA4B,CAAC;sBACvB,CAAC;wBAA8B,CAAC;wBAEnC,CAAC;;;4BA2BK,CAAC;kCACwB,CAAC;wBACrC,CAAA;wBAA+B,CAAC;wCAK9B,CAAJ;2BAAkC,CAAC;kCACP,CAAC;2BAIhB,CAAC;qBAA4B,CAAC;;;uBAsBT,CAAC;6BACH,CAAC;8BAI7B,CAAF;6BAAoC,CAAC;0BAClB,CAAC;6BAIhB,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBA1CJ,CAAF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAvDE,CAAA;;;;;;;;;;;;qBAuBC,CAAC;sBAA4B,CAAC;sBACvB,CAAC;wBAA8B,CAAC;wBAEnC,CAAC;;;4BA2BK,CAAC;kCACwB,CAAC;wBACrC,CAAA;wBAA+B,CAAC;wCAK9B,CAAJ;2BAAkC,CAAC;kCACP,CAAC;2BAIhB,CAAC;qBAA4B,CAAC;;;uBAsBT,CAAC;6BACH,CAAC;8BAI7B,CAAF;6BAAoC,CAAC;0BAClB,CAAC;6BAIhB,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBA1CJ,CAAF;;;;;;;;;;;;;;;;;;;EApBD"}
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../src/search.js"],"names":[],"mappings":"AAuBA,gEAaC;AAED;;;;;;;;;;;;kBA8GU,CAAP;oBACmB,CAAC;qBAGX,CAAN;sBAEE,CAAR;;;;;;;;;;;;;;;;;;;;;;;;;;;;eArDE,CADF;;;;;;;;;;;;;;;;;EArCC;AAED;;;;;;;;;;;;;;;;;mBAtBI,CAAA;;;;;;;;;;;;qBAuBC,CAAC;sBAA4B,CAAC;sBACvB,CAAC;wBAA8B,CAAC;wBAEnC,CAAC;;;4BA2BK,CAAC;kCACwB,CAAC;wBACrC,CAAA;wBAA+B,CAAC;wCAK9B,CAAJ;2BAAkC,CAAC;kCACP,CAAC;2BAIhB,CAAC;qBAA4B,CAAC;;;uBAsBT,CAAC;6BACH,CAAC;8BAI7B,CAAF;6BAAoC,CAAC;0BAClB,CAAC;6BAIhB,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAvCN,CADF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAzDI,CAAA;;;;;;;;;;;;qBAuBC,CAAC;sBAA4B,CAAC;sBACvB,CAAC;wBAA8B,CAAC;wBAEnC,CAAC;;;4BA2BK,CAAC;kCACwB,CAAC;wBACrC,CAAA;wBAA+B,CAAC;wCAK9B,CAAJ;2BAAkC,CAAC;kCACP,CAAC;2BAIhB,CAAC;qBAA4B,CAAC;;;uBAsBT,CAAC;6BACH,CAAC;8BAI7B,CAAF;6BAAoC,CAAC;0BAClB,CAAC;6BAIhB,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAvCN,CADF;;;;;;;;;;;;;;;;;;;;EAtBC"}

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

@@ -1 +1 @@
-{"version":3,"file":"soft-delete.d.ts","sourceRoot":"","sources":["../src/soft-delete.js"],"names":[],"mappings":"AAOA,mDAIC;AAED,0DAwBC"}
+{"version":3,"file":"soft-delete.d.ts","sourceRoot":"","sources":["../src/soft-delete.js"],"names":[],"mappings":"AAMA,mDAIC;AAED,0DAwBC"}

package/types/validation-schemas.d.ts

@@ -30,6 +30,9 @@ export const DATE_SCHEMA: {
     getAnyType(): {
         type: string[];
     };
+    getFormat(): {
+        format: any;
+    };
     getDefault(): {
         default?: undefined;
     } | {
@@ -39,6 +42,7 @@ export const DATE_SCHEMA: {
         nullable: boolean;
     };
     getEnum(): any;
+    requireAllWithin(): /*elided*/ any;
     expandExtra(extra?: {}): {};
     inspect(): string;
     get(): void;
@@ -132,6 +136,9 @@ export const OBJECT_ID_SCHEMA: {
     getAnyType(): {
         type: string[];
     };
+    getFormat(): {
+        format: any;
+    };
     getDefault(): {
         default?: undefined;
     } | {
@@ -141,6 +148,7 @@ export const OBJECT_ID_SCHEMA: {
         nullable: boolean;
     };
     getEnum(): any;
+    requireAllWithin(): /*elided*/ any;
     expandExtra(extra?: {}): {};
     inspect(): string;
     get(): void;
@@ -159,12 +167,15 @@ export const NUMBER_RANGE_SCHEMA: {
     pick(...names?: string[]): /*elided*/ any;
     omit(...names?: string[]): /*elided*/ any;
     require(...fields: string[]): /*elided*/ any;
+    requireAll(): /*elided*/ any;
+    requireAllWithin(): /*elided*/ any;
     export(): any;
     append(arg: import("@bedrockio/yada/types/object").SchemaMap | import("@bedrockio/yada/types/Schema").default): /*elided*/ any;
     options(options?: {
         stripEmpty?: boolean;
         stripUnknown?: boolean;
-        preserveKeys?: boolean;
+        allowFlatKeys?: boolean;
+        expandFlatKeys?: boolean;
     }): /*elided*/ any;
     format(name: any, fn: any): /*elided*/ any;
     toString(): any;
@@ -188,6 +199,9 @@ export const NUMBER_RANGE_SCHEMA: {
     getAnyType(): {
         type: string[];
     };
+    getFormat(): {
+        format: any;
+    };
     getDefault(): {
         default?: undefined;
     } | {
@@ -214,12 +228,15 @@ export const STRING_RANGE_SCHEMA: {
     pick(...names?: string[]): /*elided*/ any;
     omit(...names?: string[]): /*elided*/ any;
     require(...fields: string[]): /*elided*/ any;
+    requireAll(): /*elided*/ any;
+    requireAllWithin(): /*elided*/ any;
     export(): any;
     append(arg: import("@bedrockio/yada/types/object").SchemaMap | import("@bedrockio/yada/types/Schema").default): /*elided*/ any;
     options(options?: {
         stripEmpty?: boolean;
         stripUnknown?: boolean;
-        preserveKeys?: boolean;
+        allowFlatKeys?: boolean;
+        expandFlatKeys?: boolean;
     }): /*elided*/ any;
     format(name: any, fn: any): /*elided*/ any;
     toString(): any;
@@ -243,6 +260,9 @@ export const STRING_RANGE_SCHEMA: {
     getAnyType(): {
         type: string[];
     };
+    getFormat(): {
+        format: any;
+    };
     getDefault(): {
         default?: undefined;
     } | {
@@ -269,12 +289,15 @@ export const DATE_RANGE_SCHEMA: {
     pick(...names?: string[]): /*elided*/ any;
     omit(...names?: string[]): /*elided*/ any;
     require(...fields: string[]): /*elided*/ any;
+    requireAll(): /*elided*/ any;
+    requireAllWithin(): /*elided*/ any;
     export(): any;
     append(arg: import("@bedrockio/yada/types/object").SchemaMap | import("@bedrockio/yada/types/Schema").default): /*elided*/ any;
     options(options?: {
         stripEmpty?: boolean;
         stripUnknown?: boolean;
-        preserveKeys?: boolean;
+        allowFlatKeys?: boolean;
+        expandFlatKeys?: boolean;
     }): /*elided*/ any;
     format(name: any, fn: any): /*elided*/ any;
     toString(): any;
@@ -298,6 +321,9 @@ export const DATE_RANGE_SCHEMA: {
     getAnyType(): {
         type: string[];
     };
+    getFormat(): {
+        format: any;
+    };
     getDefault(): {
         default?: undefined;
     } | {

package/types/validation-schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validation-schemas.d.ts","sourceRoot":"","sources":["../src/validation-schemas.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAsFgD,CAAC;;;;;;;;;;;;;;;;;;EAtFS;AAE1D;;;;;;;;;;;;;;;;eAyBwB,CAAC;;;;;;;;;;;;iBAuBjB,CAAA;kBAA4B,CAAC;kBAEjC,CAAF;oBAEI,CAAC;oBAEI,CAAC;;;wBA2BC,CAAC;8BAGI,CAAC;oBAA+B,CAAC;oBAE1C,CAAC;oCAEL,CAAC;uBAAkC,CAAC;8BAAyC,CAAC;uBACzD,CAAC;iBAA4B,CAAC;;;mBAG0V,CAAC;yBAAoC,CAAC;0BAAqC,CAAC;yBAAoC,CAAC;sBAAiC,CAAC;yBAAoC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAR1hB,CAAC;;;;;;;;;;;;;;;;;;EA5E5C;AAEL;;;;;;;;;;kBAkFwU,CAAC;oBAA+B,CAAC;oBAA+B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;eARzV,CAAC;;;;;;;;;;;;;;;;;EAhE5C;AAEL;;;;;;;;;;kBAsEwU,CAAC;oBAA+B,CAAC;oBAA+B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;eARzV,CAAC;;;;;;;;;;;;;;;;;EApD5C;AAEL;;;;;;;;;;kBA0DwU,CAAC;oBAA+B,CAAC;oBAA+B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;eARzV,CAAC;;;;;;;;;;;;;;;;;EAhB5C;AAEL,8EAqBK"}
+{"version":3,"file":"validation-schemas.d.ts","sourceRoot":"","sources":["../src/validation-schemas.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAwFsB,CAAC;;;;;;;;;;;;;;;;;;;EAxFmC;AAE1D;;;;;;;;;;;;;;;;eAyBwB,CAAC;;;;;;;;;;;;iBAuBjB,CAAA;kBAA4B,CAAC;kBAEjC,CAAF;oBAEI,CAAC;oBAEI,CAAC;;;wBA2BC,CAAC;8BAGI,CAAC;oBAA+B,CAAC;oBAE1C,CAAC;oCAEL,CAAC;uBAAkC,CAAC;8BAAyC,CAAC;uBACzD,CAAC;iBAA4B,CAAC;;;mBAG0V,CAAC;yBAAoC,CAAC;0BAAqC,CAAC;yBAAoC,CAAC;sBAAiC,CAAC;yBAAoC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eANpjB,CAAC;;;;;;;;;;;;;;;;;;;EA9ElB;AAEL;;;;;;;;;;;;kBAkFmtB,CAAC;oBAA+B,CAAC;qBAAgC,CAAC;sBAAiC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;eANjyB,CAAC;;;;;;;;;;;;;;;;;EAlElB;AAEL;;;;;;;;;;;;kBAsEmtB,CAAC;oBAA+B,CAAC;qBAAgC,CAAC;sBAAiC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;eANjyB,CAAC;;;;;;;;;;;;;;;;;EAtDlB;AAEL;;;;;;;;;;;;kBA0DmtB,CAAC;oBAA+B,CAAC;qBAAgC,CAAC;sBAAiC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;eANjyB,CAAC;;;;;;;;;;;;;;;;;EAlBlB;AAEL,8EAqBK"}

package/types/validation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.js"],"names":[],"mappings":"AA0DA,kDAEC;AAED,oEA0FC;AAsBD,wEAiBC;AAwSD;;;EAEC;AAED;;;EAOC"}
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.js"],"names":[],"mappings":"AA0DA,kDAEC;AAED,oEA4FC;AAsBD,wEAiBC;AA8SD;;;EAEC;AAED;;;EAOC"}