@bedrockio/model 0.17.0 → 0.18.1

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,13 @@
+## 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`.
+
 ## 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/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;
@@ -360,7 +365,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 +374,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,64 @@
+"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 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);
+    }
+  });
+}
+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,8 +12,10 @@ 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");
 var _search = require("./search");
 var _serialization = require("./serialization");
 var _slug = require("./slug");
@@ -58,6 +60,8 @@ function createSchema(definition, options = {}) {
   (0, _search.applySearch)(schema, definition);
   (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);

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.1",
   "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/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

@@ -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
@@ -145,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;
@@ -363,17 +369,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,75 @@
+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 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);
+    }
+  });
+}
+
+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

@@ -6,8 +6,10 @@ import { applyCache } from './cache';
 import { applyClone } from './clone';
 import { applyDeleteHooks } from './delete-hooks';
 import { applyDisallowed } from './disallowed';
+import { applyExport } from './export';
 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 +63,8 @@ export function createSchema(definition, options = {}) {
   applySearch(schema, definition);
   applyCache(schema, definition);
   applyClone(schema);
+  applyReload(schema);
+  applyExport(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/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/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,+CAwBC"}

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":"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"}

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"}