@bedrockio/model 0.17.0 → 0.18.0

package/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.18.0
+
+- Added `reload`.
+
 ## 0.17.0
 
 - Added `time` validation.

package/README.md

@@ -23,6 +23,7 @@ Bedrock utilities for model creation.
   - [Access Control](#access-control)
   - [Assign](#assign)
   - [Upsert](#upsert)
+  - [Reload](#reload)
   - [Clone](#clone)
   - [Slugs](#slugs)
 - [Testing](#testing)
@@ -1752,6 +1753,32 @@ if (!shop) {
 }
 ```
 
+### Reload
+
+Adds a single `reload` method that reloads a document in place. This is useful
+for testing purposes, etc:
+
+```js
+const shop = await Shop.create({
+  name: 'My Shop',
+});
+
+await Shop.updateOne(
+  {
+    _id: shop._id,
+  },
+  {
+    $set: {
+      name: 'My New Shop',
+    },
+  },
+);
+
+await shop.reload();
+
+shop.name; // Now "My New Shop"
+```
+
 ### Clone
 
 Adds a single `clone` method on documents. This is an async method mostly for

package/dist/cjs/include.js

@@ -360,7 +360,7 @@ function resolvePaths(schema, str) {
     source = source.replaceAll('\\*', '[^.]+');
     source = `^${source}$`;
     const reg = RegExp(source);
-    paths = getSchemaPaths(schema).filter(path => {
+    paths = (0, _utils.getSchemaPaths)(schema).filter(path => {
       return reg.test(path);
     });
   } else {
@@ -369,17 +369,4 @@ function resolvePaths(schema, str) {
   return paths.map(path => {
     return [path, schema.pathType(path)];
   });
-}
-function getSchemaPaths(schema) {
-  return Object.entries(schema.paths || {}).flatMap(([key, schema]) => {
-    if (key.startsWith('_')) {
-      return [];
-    } else if (schema.schema) {
-      return getSchemaPaths(schema.schema).map(path => {
-        return [key, path].join('.');
-      });
-    } else {
-      return [key];
-    }
-  });
 }

package/dist/cjs/reload.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.applyReload = applyReload;
+var _mongoose = _interopRequireDefault(require("mongoose"));
+var _utils = require("./utils");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+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');
+    }
+    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 getReferencePaths(schema) {
+  return (0, _utils.getSchemaPaths)(schema).filter(path => {
+    return (0, _utils.isReferenceField)(schema, path);
+  });
+}

package/dist/cjs/schema.js

@@ -14,6 +14,7 @@ var _deleteHooks = require("./delete-hooks");
 var _disallowed = require("./disallowed");
 var _hydrate = require("./hydrate");
 var _include = require("./include");
+var _reload = require("./reload");
 var _search = require("./search");
 var _serialization = require("./serialization");
 var _slug = require("./slug");
@@ -58,6 +59,7 @@ function createSchema(definition, options = {}) {
   (0, _search.applySearch)(schema, definition);
   (0, _cache.applyCache)(schema, definition);
   (0, _clone.applyClone)(schema);
+  (0, _reload.applyReload)(schema);
   (0, _disallowed.applyDisallowed)(schema);
   (0, _include.applyInclude)(schema);
   (0, _hydrate.applyHydrate)(schema);

package/dist/cjs/utils.js

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.getField = getField;
 exports.getInnerField = getInnerField;
+exports.getSchemaPaths = getSchemaPaths;
 exports.isArrayField = isArrayField;
 exports.isDateField = isDateField;
 exports.isEqual = isEqual;
@@ -149,4 +150,17 @@ function resolveInnerField(field) {
     field = field.obj;
   }
   return field;
+}
+function getSchemaPaths(schema) {
+  return Object.entries(schema.paths || {}).flatMap(([key, schema]) => {
+    if (key.startsWith('_')) {
+      return [];
+    } else if (schema.schema) {
+      return getSchemaPaths(schema.schema).map(path => {
+        return [key, path].join('.');
+      });
+    } else {
+      return [key];
+    }
+  });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bedrockio/model",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "description": "Bedrock utilities for model creation.",
   "type": "module",
   "scripts": {
@@ -45,7 +45,7 @@
     "jest": "^30.2.0",
     "jest-environment-node": "^30.2.0",
     "mongodb": "^6.20.0",
-    "mongoose": "^8.18.2",
+    "mongoose": "^8.19.2",
     "prettier": "^3.6.2",
     "typescript": "^5.9.2"
   },

package/src/include.js

@@ -2,6 +2,7 @@ import { escapeRegExp } from 'lodash';
 import mongoose from 'mongoose';
 
 import { POPULATE_MAX_DEPTH } from './const';
+import { getSchemaPaths } from './utils';
 import { getInnerField, isSchemaTypedef } from './utils';
 
 // @ts-ignore
@@ -363,17 +364,3 @@ function resolvePaths(schema, str) {
     return [path, schema.pathType(path)];
   });
 }
-
-function getSchemaPaths(schema) {
-  return Object.entries(schema.paths || {}).flatMap(([key, schema]) => {
-    if (key.startsWith('_')) {
-      return [];
-    } else if (schema.schema) {
-      return getSchemaPaths(schema.schema).map((path) => {
-        return [key, path].join('.');
-      });
-    } else {
-      return [key];
-    }
-  });
-}

package/src/reload.js

@@ -0,0 +1,30 @@
+import mongoose from 'mongoose';
+
+import { getSchemaPaths } from './utils';
+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');
+    }
+
+    this.overwrite(doc);
+  });
+}
+
+function getPopulatedPaths(doc) {
+  return getReferencePaths(doc.constructor.schema).filter((path) => {
+    const value = doc.get(path);
+    return value && !mongoose.isObjectIdOrHexString(value);
+  });
+}
+
+function getReferencePaths(schema) {
+  return getSchemaPaths(schema).filter((path) => {
+    return isReferenceField(schema, path);
+  });
+}

package/src/schema.js

@@ -8,6 +8,7 @@ import { applyDeleteHooks } from './delete-hooks';
 import { applyDisallowed } from './disallowed';
 import { applyHydrate } from './hydrate';
 import { applyInclude } from './include';
+import { applyReload } from './reload';
 import { applySearch } from './search';
 import { serializeOptions } from './serialization';
 import { applySlug } from './slug';
@@ -61,6 +62,7 @@ export function createSchema(definition, options = {}) {
   applySearch(schema, definition);
   applyCache(schema, definition);
   applyClone(schema);
+  applyReload(schema);
   applyDisallowed(schema);
   applyInclude(schema);
   applyHydrate(schema);

package/src/utils.js

@@ -139,3 +139,17 @@ function resolveInnerField(field) {
   }
   return field;
 }
+
+export function getSchemaPaths(schema) {
+  return Object.entries(schema.paths || {}).flatMap(([key, schema]) => {
+    if (key.startsWith('_')) {
+      return [];
+    } else if (schema.schema) {
+      return getSchemaPaths(schema.schema).map((path) => {
+        return [key, path].join('.');
+      });
+    } else {
+      return [key];
+    }
+  });
+}

package/types/include.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"include.d.ts","sourceRoot":"","sources":["../src/include.js"],"names":[],"mappings":"AAiBA,gDAuEC;AAMD,uDA4BC;AAGD,yDAIC;AAaD,yEAUC"}
+{"version":3,"file":"include.d.ts","sourceRoot":"","sources":["../src/include.js"],"names":[],"mappings":"AAkBA,gDAuEC;AAMD,uDA4BC;AAGD,yDAIC;AAaD,yEAUC"}

package/types/reload.d.ts

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

package/types/reload.d.ts.map

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

package/types/schema.d.ts

@@ -19,6 +19,7 @@ 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":"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"}
+{"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"}

package/types/utils.d.ts

@@ -13,5 +13,6 @@ export function resolveRefPath(schema: any, path: any): {
     foreign: any;
 };
 export function getInnerField(obj: any, path: any): any;
+export function getSchemaPaths(schema: any): any;
 import mongoose from 'mongoose';
 //# sourceMappingURL=utils.d.ts.map

package/types/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.js"],"names":[],"mappings":"AAQA,iDAcC;AAED,gHAEC;AAED,+DAEC;AAED,0DAEC;AAED,4DAEC;AAED,4DAEC;AAED,2DAGC;AAOD,mDAGC;AAuBD,mDAgBC;AAKD;;;;EAoBC;AAKD,wDAEC;qBAhIoB,UAAU"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.js"],"names":[],"mappings":"AAQA,iDAcC;AAED,gHAEC;AAED,+DAEC;AAED,0DAEC;AAED,4DAEC;AAED,4DAEC;AAED,2DAGC;AAOD,mDAGC;AAuBD,mDAgBC;AAKD;;;;EAoBC;AAKD,wDAEC;AAcD,iDAYC;qBA1JoB,UAAU"}