@bedrockio/model 0.3.1 → 0.4.0

package/dist/cjs/assign.js

@@ -5,14 +5,15 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.applyAssign = applyAssign;
 var _lodash = require("lodash");
+var _mongoose = _interopRequireDefault(require("mongoose"));
 var _utils = require("./utils");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 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) {
         this.set(path, undefined);
-        this.markModified(path);
       } else {
         this.set(path, value);
       }
@@ -27,6 +28,8 @@ 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 (value && typeof value === 'object') {
       unsetReferenceFields(value, (0, _utils.getField)(schema, key));
     }

package/dist/cjs/hydrate.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.applyHydrate = applyHydrate;
+var _mongoose = require("mongoose");
+// Patching mongoose hydrate method to be less useless
+// as it sets all input fields on the resulting document.
+// Compare this to creating a new model which will only
+// set the fields known to the schema. This results in:
+//
+// 1. Sending too much data down the wire
+// 2. Potentially leaking sensitive data in aggregations.
+
+function applyHydrate(schema) {
+  schema.static('hydrate', function hydrate(obj) {
+    return _mongoose.Model.hydrate.call(this, obj, getProjection(schema));
+  });
+}
+
+// Note that the mongoose docs imply that an array of
+// strings will work for the projection, however this
+// does not seem to work.
+// https://mongoosejs.com/docs/7.x/docs/api/model.html
+function getProjection(schema) {
+  const keys = Object.keys(schema.paths);
+  const result = {};
+  for (let key of keys) {
+    result[key] = true;
+  }
+  return result;
+}

package/dist/cjs/schema.js

@@ -12,6 +12,7 @@ var _serialization = require("./serialization");
 var _slug = require("./slug");
 var _search = require("./search");
 var _assign = require("./assign");
+var _hydrate = require("./hydrate");
 var _include = require("./include");
 var _softDelete = require("./soft-delete");
 var _deleteHooks = require("./delete-hooks");
@@ -54,6 +55,7 @@ function createSchema(definition, options = {}) {
   (0, _search.applySearch)(schema, definition);
   (0, _disallowed.applyDisallowed)(schema);
   (0, _include.applyInclude)(schema);
+  (0, _hydrate.applyHydrate)(schema);
   (0, _assign.applyAssign)(schema);
   (0, _slug.applySlug)(schema);
   return schema;

package/dist/cjs/validation.js

@@ -282,11 +282,14 @@ function getSchemaForTypedef(typedef, options = {}) {
     schema = getObjectSchema(type, options);
   } else {
     schema = getSchemaForType(type, options);
+
+    // Unsetting only allowed for primitive types.
+    if (allowUnset(typedef, options)) {
+      schema = _yada.default.allow(null, '', schema);
+    }
   }
   if (isRequired(typedef, options)) {
     schema = schema.required();
-  } else if (allowUnset(typedef, options)) {
-    schema = _yada.default.allow(null, '', schema);
   }
   if (typedef.default && options.allowDefaultTags) {
     // Tag the default value to allow OpenAPI description

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bedrockio/model",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "Bedrock utilities for model creation.",
   "type": "module",
   "scripts": {
@@ -31,7 +31,7 @@
   },
   "peerDependencies": {
     "@bedrockio/yada": "^1.0.40",
-    "mongoose": "^7.6.4"
+    "mongoose": "^7.6.13"
   },
   "devDependencies": {
     "@babel/cli": "^7.20.7",
@@ -39,13 +39,13 @@
     "@babel/preset-env": "^7.20.2",
     "@bedrockio/prettier-config": "^1.0.2",
     "@bedrockio/yada": "^1.0.40",
-    "@shelf/jest-mongodb": "^4.2.0",
+    "@shelf/jest-mongodb": "^4.3.2",
     "eslint": "^8.33.0",
     "eslint-plugin-bedrock": "^1.0.26",
     "jest": "^29.4.1",
     "jest-environment-node": "^29.4.1",
     "mongodb": "^6.5.0",
-    "mongoose": "^7.6.4",
+    "mongoose": "7.6.13",
     "prettier-eslint": "^15.0.1",
     "typescript": "^4.9.5"
   },

package/src/assign.js

@@ -1,4 +1,5 @@
 import { isPlainObject } from 'lodash';
+import mongoose from 'mongoose';
 
 import { isReferenceField, getField } from './utils';
 
@@ -8,7 +9,6 @@ export function applyAssign(schema) {
     for (let [path, value] of Object.entries(flattenObject(fields))) {
       if (value === null) {
         this.set(path, undefined);
-        this.markModified(path);
       } else {
         this.set(path, value);
       }
@@ -23,6 +23,8 @@ 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 (value && typeof value === 'object') {
       unsetReferenceFields(value, getField(schema, key));
     }

package/src/hydrate.js

@@ -0,0 +1,28 @@
+import { Model } from 'mongoose';
+
+// Patching mongoose hydrate method to be less useless
+// as it sets all input fields on the resulting document.
+// Compare this to creating a new model which will only
+// set the fields known to the schema. This results in:
+//
+// 1. Sending too much data down the wire
+// 2. Potentially leaking sensitive data in aggregations.
+
+export function applyHydrate(schema) {
+  schema.static('hydrate', function hydrate(obj) {
+    return Model.hydrate.call(this, obj, getProjection(schema));
+  });
+}
+
+// Note that the mongoose docs imply that an array of
+// strings will work for the projection, however this
+// does not seem to work.
+// https://mongoosejs.com/docs/7.x/docs/api/model.html
+function getProjection(schema) {
+  const keys = Object.keys(schema.paths);
+  const result = {};
+  for (let key of keys) {
+    result[key] = true;
+  }
+  return result;
+}

package/src/schema.js

@@ -7,6 +7,7 @@ import { serializeOptions } from './serialization';
 import { applySlug } from './slug';
 import { applySearch } from './search';
 import { applyAssign } from './assign';
+import { applyHydrate } from './hydrate';
 import { applyInclude } from './include';
 import { applySoftDelete } from './soft-delete';
 import { applyDeleteHooks } from './delete-hooks';
@@ -58,6 +59,7 @@ export function createSchema(definition, options = {}) {
   applySearch(schema, definition);
   applyDisallowed(schema);
   applyInclude(schema);
+  applyHydrate(schema);
   applyAssign(schema);
   applySlug(schema);
 

package/src/validation.js

@@ -297,12 +297,15 @@ function getSchemaForTypedef(typedef, options = {}) {
     schema = getObjectSchema(type, options);
   } else {
     schema = getSchemaForType(type, options);
+
+    // Unsetting only allowed for primitive types.
+    if (allowUnset(typedef, options)) {
+      schema = yd.allow(null, '', schema);
+    }
   }
 
   if (isRequired(typedef, options)) {
     schema = schema.required();
-  } else if (allowUnset(typedef, options)) {
-    schema = yd.allow(null, '', schema);
   }
 
   if (typedef.default && options.allowDefaultTags) {

package/types/assign.d.ts.map

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

package/types/hydrate.d.ts

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

package/types/hydrate.d.ts.map

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

package/types/load.d.ts

@@ -4,7 +4,73 @@
  * @param {string} name
  * @returns mongoose.Model
  */
-export function loadModel(definition: object, name: string): any;
+export function loadModel(definition: object, name: string): mongoose.Model<any, any, any, any, any, mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, any, any, any, {
+    [x: string]: any;
+}, {
+    autoIndex?: boolean;
+    autoCreate?: boolean;
+    bufferCommands?: boolean;
+    bufferTimeoutMS?: number;
+    capped?: number | boolean | {
+        size?: number;
+        max?: number;
+        autoIndexId?: boolean;
+    };
+    collation?: mongoose.mongo.CollationOptions;
+    collectionOptions?: mongoose.mongo.CreateCollectionOptions;
+    timeseries?: mongoose.mongo.TimeSeriesCollectionOptions;
+    expireAfterSeconds?: number;
+    expires?: string | number;
+    collection?: string;
+    discriminatorKey?: string;
+    excludeIndexes?: boolean;
+    id?: boolean;
+    _id?: boolean;
+    minimize?: boolean;
+    optimisticConcurrency?: boolean;
+    pluginTags?: string[];
+    read?: string;
+    writeConcern?: mongoose.mongo.WriteConcern;
+    safe?: boolean | {
+        w?: string | number;
+        wtimeout?: number;
+        j?: boolean;
+    };
+    shardKey?: Record<string, unknown>;
+    strict?: boolean | "throw";
+    strictQuery?: boolean | "throw";
+    toJSON: {
+        getters: boolean;
+        versionKey: boolean;
+        transform: (doc: any, ret: any, options: any) => void;
+    } | mongoose.ToObjectOptions<any>;
+    toObject: {
+        getters: boolean;
+        versionKey: boolean;
+        transform: (doc: any, ret: any, options: any) => void;
+    } | mongoose.ToObjectOptions<any>;
+    typeKey?: string;
+    validateBeforeSave?: boolean;
+    validateModifiedOnly?: boolean;
+    versionKey?: string | boolean;
+    selectPopulatedPaths?: boolean;
+    skipVersioning?: {
+        [key: string]: boolean;
+    };
+    storeSubdocValidationError?: boolean;
+    timestamps: boolean | mongoose.SchemaTimestampsConfig;
+    suppressReservedKeysWarning?: boolean;
+    statics?: {
+        [x: string]: any;
+    };
+    methods?: any;
+    query?: any;
+    castNonArrays?: boolean;
+    virtuals?: mongoose.SchemaOptionsVirtualsPropertyType<any, any, any>;
+    overwriteModels?: boolean;
+}, any, any>> & {
+    [x: string]: any;
+};
 /**
  * Loads all model definitions in the given directory.
  * Returns the full loaded model set.

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"}
+{"version":3,"file":"load.d.ts","sourceRoot":"","sources":["../src/load.js"],"names":[],"mappings":"AAQA;;;;;GAKG;AACH,sCAJW,MAAM,QACN,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAahB;AAED;;;;GAIG;AACH,sCAFW,MAAM,mBAkBhB"}

package/types/schema.d.ts

@@ -6,9 +6,10 @@
  * @param {mongoose.SchemaOptions} options
  * @returns mongoose.Schema
  */
-export function createSchema(definition: object, options?: mongoose.SchemaOptions): mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, any, any, any, any, {
+export function createSchema(definition: object, options?: mongoose.SchemaOptions): mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, any, any, any, {
+    [x: string]: any;
+}, {
     autoIndex?: boolean;
-    autoSearchIndex?: boolean;
     autoCreate?: boolean;
     bufferCommands?: boolean;
     bufferTimeoutMS?: number;
@@ -61,8 +62,10 @@ 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>>;
-    methods?: mongoose.AddThisParameter<any, any> & mongoose.AnyObject;
+    statics?: {
+        [x: string]: any;
+    };
+    methods?: any;
     query?: any;
     castNonArrays?: boolean;
     virtuals?: mongoose.SchemaOptionsVirtualsPropertyType<any, any, any>;

package/types/schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.js"],"names":[],"mappings":"AAoBA;;;;;;;GAOG;AACH,yCAJW,MAAM,YACN,SAAS,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAuChC;AAED,iEAsBC"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.js"],"names":[],"mappings":"AAqBA;;;;;;;GAOG;AACH,yCAJW,MAAM,YACN,SAAS,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAwChC;AAED,iEAsBC"}

package/types/validation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.js"],"names":[],"mappings":"AAkFA,kDAEC;AAED,oEA8FC;AAsBD,wEA2BC;AAgSD;;;EAEC;AAED;;;EAOC;AA9fD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQK"}
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.js"],"names":[],"mappings":"AAkFA,kDAEC;AAED,oEA8FC;AAsBD,wEA2BC;AAmSD;;;EAEC;AAED;;;EAOC;AAjgBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQK"}