@bedrockio/model 0.2.20 → 0.2.22

package/dist/cjs/access.js

@@ -4,22 +4,13 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.hasAccess = hasAccess;
-exports.hasReadAccess = hasReadAccess;
-exports.hasWriteAccess = hasWriteAccess;
 var _errors = require("./errors");
 var _warn = _interopRequireDefault(require("./warn"));
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-function hasReadAccess(allowed, options) {
-  return hasAccess('read', allowed, options);
-}
-function hasWriteAccess(allowed, options) {
-  return hasAccess('write', allowed, options);
-}
-
 /**
  * @param {string|string[]} allowed
  */
-function hasAccess(type, allowed = 'all', options = {}) {
+function hasAccess(allowed = 'all', options = {}) {
   if (allowed === 'all') {
     return true;
   } else if (allowed === 'none') {

package/dist/cjs/include.js

@@ -6,7 +6,8 @@ Object.defineProperty(exports, "__esModule", {
 exports.INCLUDE_FIELD_SCHEMA = void 0;
 exports.applyInclude = applyInclude;
 exports.checkSelects = checkSelects;
-exports.getIncludes = getIncludes;
+exports.getDocumentParams = getDocumentParams;
+exports.getParams = getParams;
 var _mongoose = _interopRequireDefault(require("mongoose"));
 var _lodash = require("lodash");
 var _yada = _interopRequireDefault(require("@bedrockio/yada"));
@@ -36,7 +37,7 @@ function applyInclude(schema) {
       const {
         select,
         populate
-      } = getQueryIncludes(this, filter.include);
+      } = getQueryParams(this, filter.include);
       this.select(select);
       this.populate(populate);
       delete filter.include;
@@ -78,7 +79,7 @@ function applyInclude(schema) {
       const {
         select,
         populate
-      } = getDocumentIncludes(this, include);
+      } = getDocumentParams(this, include);
       this.$locals.select = select;
       this.$locals.populate = populate;
     }
@@ -103,7 +104,7 @@ function applyInclude(schema) {
       const {
         select,
         populate
-      } = getDocumentIncludes(this, include);
+      } = getDocumentParams(this, include);
       this.$locals.select = select;
       await this.populate(populate);
     }
@@ -147,16 +148,32 @@ function checkSelects(doc, ret) {
 }
 
 // Exported for testing.
-function getIncludes(modelName, arg) {
+function getParams(modelName, arg) {
   const paths = Array.isArray(arg) ? arg : [arg];
   const node = pathsToNode(paths, modelName);
   return nodeToPopulates(node);
 }
-function getQueryIncludes(query, arg) {
-  return getIncludes(query.model.modelName, arg);
+
+// Exported for testing.
+function getDocumentParams(doc, arg) {
+  const params = getParams(doc.constructor.modelName, arg);
+  params.populate = params.populate.filter(p => {
+    return !isDocumentPopulated(doc, p);
+  });
+  return params;
+}
+function isDocumentPopulated(doc, params) {
+  if (doc.populated(params.path)) {
+    const sub = doc.get(params.path);
+    return params.populate.every(p => {
+      return isDocumentPopulated(sub, p);
+    });
+  } else {
+    return false;
+  }
 }
-function getDocumentIncludes(doc, arg) {
-  return getIncludes(doc.constructor.modelName, arg);
+function getQueryParams(query, arg) {
+  return getParams(query.model.modelName, arg);
 }
 
 // Note that:
@@ -181,6 +198,12 @@ function nodeToPopulates(node) {
     populate
   };
 }
+
+// Null serves as a flag that the key terminates
+// the branch and this is a leaf node. Using null
+// here as it's simple and serializes to JSON for
+// easy inspection.
+const LEAF_NODE = null;
 function pathsToNode(paths, modelName) {
   const node = {};
   for (let str of paths) {
@@ -228,7 +251,7 @@ function setNodePath(node, options) {
         // -user.name - Implies population of "user" but exclude "user.name",
         //  so continue traversing into object when part is "user".
         if (isExact && exclude) {
-          node['-' + key] = null;
+          node['-' + key] = LEAF_NODE;
         } else if (field.ref) {
           node[key] ||= {};
           setNodePath(node[key], {
@@ -239,7 +262,7 @@ function setNodePath(node, options) {
           });
           halt = true;
         } else if ((0, _utils.isSchemaTypedef)(field)) {
-          node[key] = null;
+          node[key] = LEAF_NODE;
         }
       } else if (type === 'virtual') {
         const virtual = schema.virtual(key);

package/dist/cjs/serialization.js

@@ -6,8 +6,8 @@ Object.defineProperty(exports, "__esModule", {
 exports.serializeOptions = void 0;
 var _lodash = require("lodash");
 var _include = require("./include");
-var _access = require("./access");
 var _utils = require("./utils");
+var _access = require("./access");
 const DISALLOWED_FIELDS = ['deleted', 'deletedRefs'];
 const serializeOptions = exports.serializeOptions = {
   getters: true,
@@ -63,7 +63,7 @@ function isAllowedField(key, field, options) {
       readAccess
     } = (0, _utils.getField)(field, key);
     try {
-      return (0, _access.hasReadAccess)(readAccess, options);
+      return (0, _access.hasAccess)(readAccess, options);
     } catch {
       return false;
     }

package/dist/cjs/validation.js

@@ -105,13 +105,13 @@ function applyValidation(schema, definition) {
       model: this,
       appendSchema,
       allowInclude,
+      allowUnset: true,
       skipRequired: true,
       stripUnknown: true,
       stripDeleted: true,
       stripTimestamps: true,
       allowExpandedRefs: true,
       requireWriteAccess: true,
-      allowNullForPrimitives: true,
       ...(hasUnique && {
         assertUniqueOptions: {
           schema,
@@ -270,8 +270,8 @@ function getSchemaForTypedef(typedef, options = {}) {
   }
   if (isRequired(typedef, options)) {
     schema = schema.required();
-  } else if (allowsNull(typedef, options)) {
-    schema = _yada.default.allow(null, schema);
+  } else if (allowUnset(typedef, options)) {
+    schema = _yada.default.allow(null, '', schema);
   }
   if (typedef.default && options.allowDefaultTags) {
     // Tag the default value to allow OpenAPI description
@@ -379,15 +379,8 @@ function getSearchSchema(schema, type) {
 function isRequired(typedef, options) {
   return typedef.required && !typedef.default && !options.skipRequired;
 }
-function allowsNull(typedef, options) {
-  if (!options.allowNullForPrimitives) {
-    return false;
-  }
-  return !typedef.required && isPrimitiveTypedef(typedef);
-}
-const PRIMITIVE_TYPES = ['String', 'Number', 'Boolean'];
-function isPrimitiveTypedef(typedef) {
-  return PRIMITIVE_TYPES.includes(typedef.type);
+function allowUnset(typedef, options) {
+  return options.allowUnset && !typedef.required;
 }
 function isExcludedField(field, options) {
   if ((0, _utils.isSchemaTypedef)(field)) {
@@ -413,7 +406,7 @@ function validateAccess(type, schema, allowed, options) {
     const document = options[(0, _lodash.lowerFirst)(modelName)] || options['document'];
     let isAllowed;
     try {
-      isAllowed = (0, _access.hasAccess)(type, allowed, {
+      isAllowed = (0, _access.hasAccess)(allowed, {
         ...options,
         document
       });

package/jest-mongodb-config.cjs

@@ -0,0 +1,14 @@
+// Note this file MUST be a CJS module as it will be required
+// by @shelf/jest-mongodb. Note also that the binary version
+// does not match the mongodb driver version.
+
+module.exports = {
+  mongodbMemoryServerOptions: {
+    binary: {
+      version: '6.0.2',
+      skipMD5: true,
+    },
+    autoStart: false,
+    instance: {},
+  },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bedrockio/model",
-  "version": "0.2.20",
+  "version": "0.2.22",
   "description": "Bedrock utilities for model creation.",
   "type": "module",
   "scripts": {
@@ -30,7 +30,7 @@
     "lodash": "^4.17.21"
   },
   "peerDependencies": {
-    "@bedrockio/yada": "^1.0.39",
+    "@bedrockio/yada": "^1.0.40",
     "mongoose": "^7.6.4"
   },
   "devDependencies": {
@@ -38,13 +38,13 @@
     "@babel/core": "^7.20.12",
     "@babel/preset-env": "^7.20.2",
     "@bedrockio/prettier-config": "^1.0.2",
-    "@bedrockio/yada": "^1.0.39",
-    "@shelf/jest-mongodb": "^4.1.7",
+    "@bedrockio/yada": "^1.0.40",
+    "@shelf/jest-mongodb": "^4.2.0",
     "eslint": "^8.33.0",
     "eslint-plugin-bedrock": "^1.0.26",
     "jest": "^29.4.1",
     "jest-environment-node": "^29.4.1",
-    "mongodb": "^6.2.0",
+    "mongodb": "^6.5.0",
     "mongoose": "^7.6.4",
     "prettier-eslint": "^15.0.1",
     "typescript": "^4.9.5"

package/src/access.js

@@ -1,18 +1,10 @@
 import { ImplementationError } from './errors';
 import warn from './warn';
 
-export function hasReadAccess(allowed, options) {
-  return hasAccess('read', allowed, options);
-}
-
-export function hasWriteAccess(allowed, options) {
-  return hasAccess('write', allowed, options);
-}
-
 /**
  * @param {string|string[]} allowed
  */
-export function hasAccess(type, allowed = 'all', options = {}) {
+export function hasAccess(allowed = 'all', options = {}) {
   if (allowed === 'all') {
     return true;
   } else if (allowed === 'none') {

package/src/include.js

@@ -31,7 +31,7 @@ export function applyInclude(schema) {
   schema.pre(/^find/, function (next) {
     const filter = this.getFilter();
     if (filter.include) {
-      const { select, populate } = getQueryIncludes(this, filter.include);
+      const { select, populate } = getQueryParams(this, filter.include);
       this.select(select);
       this.populate(populate);
       delete filter.include;
@@ -70,7 +70,7 @@ export function applyInclude(schema) {
     this.assign(rest);
 
     if (include) {
-      const { select, populate } = getDocumentIncludes(this, include);
+      const { select, populate } = getDocumentParams(this, include);
       this.$locals.select = select;
       this.$locals.populate = populate;
     }
@@ -91,7 +91,7 @@ export function applyInclude(schema) {
   // during serialization.
   schema.method('include', async function include(include) {
     if (include) {
-      const { select, populate } = getDocumentIncludes(this, include);
+      const { select, populate } = getDocumentParams(this, include);
       this.$locals.select = select;
       await this.populate(populate);
     }
@@ -133,18 +133,34 @@ export function checkSelects(doc, ret) {
 }
 
 // Exported for testing.
-export function getIncludes(modelName, arg) {
+export function getParams(modelName, arg) {
   const paths = Array.isArray(arg) ? arg : [arg];
   const node = pathsToNode(paths, modelName);
   return nodeToPopulates(node);
 }
 
-function getQueryIncludes(query, arg) {
-  return getIncludes(query.model.modelName, arg);
+// Exported for testing.
+export function getDocumentParams(doc, arg) {
+  const params = getParams(doc.constructor.modelName, arg);
+  params.populate = params.populate.filter((p) => {
+    return !isDocumentPopulated(doc, p);
+  });
+  return params;
+}
+
+function isDocumentPopulated(doc, params) {
+  if (doc.populated(params.path)) {
+    const sub = doc.get(params.path);
+    return params.populate.every((p) => {
+      return isDocumentPopulated(sub, p);
+    });
+  } else {
+    return false;
+  }
 }
 
-function getDocumentIncludes(doc, arg) {
-  return getIncludes(doc.constructor.modelName, arg);
+function getQueryParams(query, arg) {
+  return getParams(query.model.modelName, arg);
 }
 
 // Note that:
@@ -170,6 +186,12 @@ function nodeToPopulates(node) {
   };
 }
 
+// Null serves as a flag that the key terminates
+// the branch and this is a leaf node. Using null
+// here as it's simple and serializes to JSON for
+// easy inspection.
+const LEAF_NODE = null;
+
 function pathsToNode(paths, modelName) {
   const node = {};
   for (let str of paths) {
@@ -214,7 +236,7 @@ function setNodePath(node, options) {
         // -user.name - Implies population of "user" but exclude "user.name",
         //  so continue traversing into object when part is "user".
         if (isExact && exclude) {
-          node['-' + key] = null;
+          node['-' + key] = LEAF_NODE;
         } else if (field.ref) {
           node[key] ||= {};
           setNodePath(node[key], {
@@ -225,7 +247,7 @@ function setNodePath(node, options) {
           });
           halt = true;
         } else if (isSchemaTypedef(field)) {
-          node[key] = null;
+          node[key] = LEAF_NODE;
         }
       } else if (type === 'virtual') {
         const virtual = schema.virtual(key);

package/src/serialization.js

@@ -1,8 +1,8 @@
 import { isPlainObject } from 'lodash';
 
 import { checkSelects } from './include';
-import { hasReadAccess } from './access';
 import { getField, getInnerField } from './utils';
+import { hasAccess } from './access';
 
 const DISALLOWED_FIELDS = ['deleted', 'deletedRefs'];
 
@@ -60,7 +60,7 @@ function isAllowedField(key, field, options) {
   } else {
     const { readAccess } = getField(field, key);
     try {
-      return hasReadAccess(readAccess, options);
+      return hasAccess(readAccess, options);
     } catch {
       return false;
     }

package/src/validation.js

@@ -118,13 +118,13 @@ export function applyValidation(schema, definition) {
         model: this,
         appendSchema,
         allowInclude,
+        allowUnset: true,
         skipRequired: true,
         stripUnknown: true,
         stripDeleted: true,
         stripTimestamps: true,
         allowExpandedRefs: true,
         requireWriteAccess: true,
-        allowNullForPrimitives: true,
         ...(hasUnique && {
           assertUniqueOptions: {
             schema,
@@ -283,8 +283,8 @@ function getSchemaForTypedef(typedef, options = {}) {
 
   if (isRequired(typedef, options)) {
     schema = schema.required();
-  } else if (allowsNull(typedef, options)) {
-    schema = yd.allow(null, schema);
+  } else if (allowUnset(typedef, options)) {
+    schema = yd.allow(null, '', schema);
   }
 
   if (typedef.default && options.allowDefaultTags) {
@@ -434,17 +434,8 @@ function isRequired(typedef, options) {
   return typedef.required && !typedef.default && !options.skipRequired;
 }
 
-function allowsNull(typedef, options) {
-  if (!options.allowNullForPrimitives) {
-    return false;
-  }
-  return !typedef.required && isPrimitiveTypedef(typedef);
-}
-
-const PRIMITIVE_TYPES = ['String', 'Number', 'Boolean'];
-
-function isPrimitiveTypedef(typedef) {
-  return PRIMITIVE_TYPES.includes(typedef.type);
+function allowUnset(typedef, options) {
+  return options.allowUnset && !typedef.required;
 }
 
 function isExcludedField(field, options) {
@@ -473,7 +464,7 @@ function validateAccess(type, schema, allowed, options) {
 
     let isAllowed;
     try {
-      isAllowed = hasAccess(type, allowed, {
+      isAllowed = hasAccess(allowed, {
         ...options,
         document,
       });

package/types/access.d.ts

@@ -1,7 +1,5 @@
-export function hasReadAccess(allowed: any, options: any): boolean;
-export function hasWriteAccess(allowed: any, options: any): boolean;
 /**
  * @param {string|string[]} allowed
  */
-export function hasAccess(type: any, allowed?: string | string[], options?: {}): boolean;
+export function hasAccess(allowed?: string | string[], options?: {}): boolean;
 //# sourceMappingURL=access.d.ts.map

package/types/access.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"access.d.ts","sourceRoot":"","sources":["../src/access.js"],"names":[],"mappings":"AAGA,mEAEC;AAED,oEAEC;AAED;;GAEG;AACH,+CAFW,MAAM,GAAC,MAAM,EAAE,yBA2BzB"}
+{"version":3,"file":"access.d.ts","sourceRoot":"","sources":["../src/access.js"],"names":[],"mappings":"AAGA;;GAEG;AACH,oCAFW,MAAM,GAAC,MAAM,EAAE,yBA2BzB"}

package/types/include.d.ts

@@ -1,6 +1,7 @@
 export function applyInclude(schema: any): void;
 export function checkSelects(doc: any, ret: any): void;
-export function getIncludes(modelName: any, arg: any): any;
+export function getParams(modelName: any, arg: any): any;
+export function getDocumentParams(doc: any, arg: any): any;
 export const INCLUDE_FIELD_SCHEMA: {
     setup: any;
     getFields: any;

package/types/include.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"include.d.ts","sourceRoot":"","sources":["../src/include.js"],"names":[],"mappings":"AA2BA,gDAuEC;AAMD,uDA4BC;AAGD,2DAIC;AAvHD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKG"}
+{"version":3,"file":"include.d.ts","sourceRoot":"","sources":["../src/include.js"],"names":[],"mappings":"AA2BA,gDAuEC;AAMD,uDA4BC;AAGD,yDAIC;AAGD,2DAMC;AAhID;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKG"}

package/types/validation.d.ts

@@ -11,6 +11,7 @@ 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;

package/types/validation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.js"],"names":[],"mappings":"AAkFA,kDAEC;AAED,oEAqFC;AAsBD,wEAkBC;AAySD;;;EAEC;AAED;;;EAOC;AArfD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQK"}
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.js"],"names":[],"mappings":"AAkFA,kDAEC;AAED,oEAqFC;AAsBD,wEAkBC;AAgSD;;;EAEC;AAED;;;EAOC;AA5eD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQK"}

package/jest-mongodb-config.js

@@ -1,12 +0,0 @@
-const { devDependencies } = require('./package.json');
-
-module.exports = {
-  mongodbMemoryServerOptions: {
-    binary: {
-      version: devDependencies.mongodb,
-      skipMD5: true,
-    },
-    autoStart: false,
-    instance: {},
-  },
-};