@bedrockio/model 0.18.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,9 @@
+## 0.18.1
+
+- Added `export` for dumping documents and to support reload.
+- Fix for `include` not working on nested virtuals.
+- Fixes for `reload`.
+
 ## 0.18.0
 
 - Added `reload`.

package/dist/cjs/export.js

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

package/dist/cjs/include.js

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

package/dist/cjs/reload.js

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

package/dist/cjs/schema.js

@@ -12,6 +12,7 @@ var _cache = require("./cache");
 var _clone = require("./clone");
 var _deleteHooks = require("./delete-hooks");
 var _disallowed = require("./disallowed");
+var _export = require("./export");
 var _hydrate = require("./hydrate");
 var _include = require("./include");
 var _reload = require("./reload");
@@ -60,6 +61,7 @@ function createSchema(definition, options = {}) {
   (0, _cache.applyCache)(schema, definition);
   (0, _clone.applyClone)(schema);
   (0, _reload.applyReload)(schema);
+  (0, _export.applyExport)(schema);
   (0, _disallowed.applyDisallowed)(schema);
   (0, _include.applyInclude)(schema);
   (0, _hydrate.applyHydrate)(schema);

package/package.json

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

package/src/export.js

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

package/src/include.js

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

package/src/reload.js

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

package/src/schema.js

@@ -6,6 +6,7 @@ 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';
@@ -63,6 +64,7 @@ export function createSchema(definition, options = {}) {
   applyCache(schema, definition);
   applyClone(schema);
   applyReload(schema);
+  applyExport(schema);
   applyDisallowed(schema);
   applyInclude(schema);
   applyHydrate(schema);

package/types/export.d.ts

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

package/types/export.d.ts.map

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

package/types/reload.d.ts.map

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

package/types/schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.js"],"names":[],"mappings":"AAwBA;;;;;;;GAOG;AACH,yCAJW,MAAM,YACN,QAAQ,CAAC,aAAa;;;;;;;YA+CX,CAAC;WAAa,CAAC;mBAEnC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;SA4HmB,CAAC;gBACL,CAAC;SAAW,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAlI9B;AAED,iEAsBC;qBAhGoB,UAAU"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.js"],"names":[],"mappings":"AAyBA;;;;;;;GAOG;AACH,yCAJW,MAAM,YACN,QAAQ,CAAC,aAAa;;;;;;;YA+CpB,CAAC;WAAa,CAAC;mBAAqB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;SA4Hf,CAAC;gBAA2B,CAAC;SAGhE,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAjIC;AAED,iEAsBC;qBAlGoB,UAAU"}