@bedrockio/model 0.3.2 → 0.4.1

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/query.js

@@ -3,6 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.mergeQuery = mergeQuery;
 exports.wrapQuery = wrapQuery;
 // Wrapper that allows a mongoose query object to be returned
 // to access chained methods while still resolving with a
@@ -18,4 +19,20 @@ function wrapQuery(query, fn) {
     }
   };
   return query;
+}
+function mergeQuery(target, source) {
+  const result = Object.assign({}, target, source);
+  if (target.$or && source.$or) {
+    const {
+      $or
+    } = target;
+    result.$or = source.$or.map(conditions => {
+      return {
+        $and: [conditions, {
+          $or
+        }]
+      };
+    });
+  }
+  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/search.js

@@ -25,10 +25,14 @@ const {
 function applySearch(schema, definition) {
   validateDefinition(definition);
   applySearchCache(schema, definition);
+  const {
+    query: searchQuery,
+    fields: searchFields
+  } = definition.search || {};
   schema.static('search', function search(body = {}) {
     const options = {
       ..._const.SEARCH_DEFAULTS,
-      ...definition.search?.query,
+      ...searchQuery,
       ...body
     };
     const {
@@ -39,16 +43,19 @@ function applySearch(schema, definition) {
       sort,
       ...rest
     } = options;
-    const query = {};
+    let query = normalizeQuery(rest, schema.obj);
     if (ids?.length) {
-      query._id = {
-        $in: ids
+      query = {
+        ...query,
+        _id: {
+          $in: ids
+        }
       };
     }
     if (keyword) {
-      Object.assign(query, buildKeywordQuery(schema, keyword, definition.search?.fields));
+      const keywordQuery = buildKeywordQuery(schema, keyword, searchFields);
+      query = (0, _query.mergeQuery)(query, keywordQuery);
     }
-    Object.assign(query, normalizeQuery(rest, schema.obj));
     if (_env.debug) {
       _logger.default.info(`Search query for ${this.modelName}:\n`, JSON.stringify(query, null, 2));
     }

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.2",
+  "version": "0.4.1",
   "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",
@@ -45,7 +45,7 @@
     "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/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/query.js

@@ -13,3 +13,16 @@ export function wrapQuery(query, fn) {
   };
   return query;
 }
+
+export function mergeQuery(target, source) {
+  const result = Object.assign({}, target, source);
+  if (target.$or && source.$or) {
+    const { $or } = target;
+    result.$or = source.$or.map((conditions) => {
+      return {
+        $and: [conditions, { $or }],
+      };
+    });
+  }
+  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/search.js

@@ -15,7 +15,7 @@ import { isDateField, isNumberField, getField } from './utils';
 import { SEARCH_DEFAULTS } from './const';
 import { OBJECT_ID_SCHEMA } from './validation';
 import { debug } from './env';
-import { wrapQuery } from './query';
+import { mergeQuery, wrapQuery } from './query';
 
 import warn from './warn';
 
@@ -26,30 +26,31 @@ export function applySearch(schema, definition) {
   validateDefinition(definition);
   applySearchCache(schema, definition);
 
+  const { query: searchQuery, fields: searchFields } = definition.search || {};
+
   schema.static('search', function search(body = {}) {
     const options = {
       ...SEARCH_DEFAULTS,
-      ...definition.search?.query,
+      ...searchQuery,
       ...body,
     };
 
     const { ids, keyword, skip = 0, limit, sort, ...rest } = options;
 
-    const query = {};
+    let query = normalizeQuery(rest, schema.obj);
 
     if (ids?.length) {
-      query._id = { $in: ids };
+      query = {
+        ...query,
+        _id: { $in: ids },
+      };
     }
 
     if (keyword) {
-      Object.assign(
-        query,
-        buildKeywordQuery(schema, keyword, definition.search?.fields)
-      );
+      const keywordQuery = buildKeywordQuery(schema, keyword, searchFields);
+      query = mergeQuery(query, keywordQuery);
     }
 
-    Object.assign(query, normalizeQuery(rest, schema.obj));
-
     if (debug) {
       logger.info(
         `Search query for ${this.modelName}:\n`,

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/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/include.d.ts

@@ -14,7 +14,7 @@ export const INCLUDE_FIELD_SCHEMA: {
     meta: {};
     required(): any;
     default(arg: any): any;
-    custom(fn: Function): any;
+    custom(...args: import("@bedrockio/yada/types/Schema").CustomSignature): any;
     strip(strip: any): any;
     allow(...set: any[]): any;
     reject(...set: any[]): any;

package/types/query.d.ts

@@ -1,2 +1,3 @@
 export function wrapQuery(query: any, fn: any): any;
+export function mergeQuery(target: any, source: any): any;
 //# sourceMappingURL=query.d.ts.map

package/types/query.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../src/query.js"],"names":[],"mappings":"AAIA,oDAUC"}
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../src/query.js"],"names":[],"mappings":"AAIA,oDAUC;AAED,0DAWC"}

package/types/schema.d.ts

@@ -8,7 +8,6 @@
  */
 export function createSchema(definition: object, options?: mongoose.SchemaOptions): mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, any, any, any, any, {
     autoIndex?: boolean;
-    autoSearchIndex?: boolean;
     autoCreate?: boolean;
     bufferCommands?: boolean;
     bufferTimeoutMS?: number;
@@ -31,9 +30,6 @@ export function createSchema(definition: object, options?: mongoose.SchemaOption
     optimisticConcurrency?: boolean;
     pluginTags?: string[];
     read?: string;
-    readConcern?: {
-        level: "local" | "available" | "majority" | "snapshot" | "linearizable";
-    };
     writeConcern?: mongoose.mongo.WriteConcern;
     safe?: boolean | {
         w?: string | number;

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/search.d.ts

@@ -11,7 +11,7 @@ export function searchValidation(options?: {}): {
     meta: {};
     required(): any;
     default(arg: any): any;
-    custom(fn: Function): any;
+    custom(...args: import("@bedrockio/yada/types/Schema").CustomSignature): any;
     strip(strip: any): any;
     allow(...set: any[]): any;
     reject(...set: any[]): any;

package/types/search.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../src/search.js"],"names":[],"mappings":"AAwBA,gEAuDC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyBC"}
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../src/search.js"],"names":[],"mappings":"AAwBA,gEAwDC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyBC"}

package/types/validation.d.ts

@@ -11,7 +11,6 @@ export function getTupleValidator(types: any): {
 };
 export const OBJECT_ID_SCHEMA: {
     required(): any;
-    allowEmpty(): any;
     length(length: number): any;
     min(length: number): any;
     max(length: number): any;
@@ -73,7 +72,7 @@ export const OBJECT_ID_SCHEMA: {
     assertions: any[];
     meta: {};
     default(arg: any): any;
-    custom(fn: Function): any;
+    custom(...args: import("@bedrockio/yada/types/Schema").CustomSignature): any;
     strip(strip: any): any;
     allow(...set: any[]): any;
     reject(...set: any[]): any;

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