@bedrockio/model 0.7.0 → 0.7.2

package/README.md

@@ -1579,11 +1579,11 @@ user.assign(ctx.request.body);
 Object.assign(user, ctx.request.body);
 ```
 
-This is functionally identical to `Object.assign` with the exception that
-`ObjectId` reference fields can be unset by passing falsy values. This method is
-provided as `undefined` cannot be represented in JSON which requires using
-either a `null` or empty string, both of which would be stored in the database
-if naively assigned with `Object.assign`.
+This is functionally identical to `Object.assign` with the exception that fields
+can be unset by passing falsy values. This method is provided as `undefined`
+cannot be represented in JSON which requires using either a `null` or empty
+string, both of which would be stored in the database if naively assigned with
+`Object.assign`.
 
 ### Upsert
 

package/dist/cjs/assign.js

@@ -12,7 +12,7 @@ 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) {
+      if (value === null || value === '') {
         this.set(path, undefined);
       } else {
         this.set(path, value);

package/dist/cjs/validation.js

@@ -83,7 +83,7 @@ function applyValidation(schema, definition) {
       model: this,
       appendSchema,
       allowInclude,
-      allowEmpty: true,
+      stripEmpty: true,
       stripDeleted: true,
       stripTimestamps: true,
       allowDefaultTags: true,
@@ -106,7 +106,7 @@ function applyValidation(schema, definition) {
       model: this,
       appendSchema,
       allowInclude,
-      allowUnset: true,
+      allowNull: true,
       skipRequired: true,
       stripUnknown: true,
       stripDeleted: true,
@@ -122,13 +122,6 @@ function applyValidation(schema, definition) {
       })
     });
   });
-  schema.static('getDeleteValidation', function getDeleteValidation() {
-    const allowed = definition.access?.delete || 'all';
-    return validateAccess('delete', _yada.default, allowed, {
-      model: this,
-      message: 'You do not have permissions to delete this document.'
-    });
-  });
   schema.static('getSearchValidation', function getSearchValidation(options = {}) {
     const {
       defaults,
@@ -138,6 +131,7 @@ function applyValidation(schema, definition) {
     return getSchemaFromMongoose(schema, {
       model: this,
       allowNull: true,
+      stripEmpty: true,
       allowSearch: true,
       skipRequired: true,
       allowInclude: true,
@@ -152,6 +146,13 @@ function applyValidation(schema, definition) {
       })
     });
   });
+  schema.static('getDeleteValidation', function getDeleteValidation() {
+    const allowed = definition.access?.delete || 'all';
+    return validateAccess('delete', _yada.default, allowed, {
+      model: this,
+      message: 'You do not have permissions to delete this document.'
+    });
+  });
   schema.static('getIncludeValidation', function getIncludeValidation() {
     return _include.INCLUDE_FIELD_SCHEMA;
   });
@@ -228,6 +229,7 @@ function getObjectSchema(arg, options) {
   } else if (typeof arg === 'object') {
     const {
       stripUnknown,
+      stripEmpty,
       expandDotSyntax
     } = options;
     const map = {};
@@ -242,6 +244,11 @@ function getObjectSchema(arg, options) {
         stripUnknown: true
       });
     }
+    if (stripEmpty) {
+      schema = schema.options({
+        stripEmpty: true
+      });
+    }
     if (expandDotSyntax) {
       schema = schema.options({
         expandDotSyntax: true
@@ -285,15 +292,24 @@ function getSchemaForTypedef(typedef, options = {}) {
   } else {
     schema = getSchemaForType(type, options);
 
-    // Only allowed for primitive types.
-    if (allowUnset(typedef, options)) {
-      schema = _yada.default.allow(schema, '').nullable();
-    } else if (allowNull(typedef, options)) {
+    // Null may be allowed to unset non-required fields
+    // in an update operation or to search for non-existent
+    // fields in a search operation.
+    if (allowNull(typedef, options)) {
       schema = schema.nullable();
-    } else if (allowEmpty(typedef, options)) {
+    }
+
+    // Empty strings are allowed to unset non-required fields
+    // in an update operation. Technically this should be null,
+    // however empty strings are allowed here as well as they
+    // generally play nicer with front-end components. For
+    // ObjectId fields the empty string must be appended here.
+    if (disallowEmpty(typedef, options)) {
       schema = schema.options({
-        allowEmpty: true
+        allowEmpty: false
       });
+    } else if (appendEmpty(typedef, options)) {
+      schema = _yada.default.allow(schema, '');
     }
   }
   if (isRequired(typedef, options)) {
@@ -406,13 +422,37 @@ function isRequired(typedef, options) {
   return typedef.required && !typedef.default && !options.skipRequired;
 }
 function allowNull(typedef, options) {
-  return options.allowNull && !typedef.required;
+  if (!options.allowNull) {
+    return false;
+  }
+  const {
+    required,
+    type
+  } = typedef;
+  return !required && type !== 'Boolean';
 }
-function allowUnset(typedef, options) {
-  return options.allowUnset && !typedef.required;
+function disallowEmpty(typedef, options) {
+  if (!options.allowNull) {
+    return false;
+  }
+  const {
+    type
+  } = typedef;
+  if (type === 'String' || type === 'ObjectId') {
+    return typedef.required;
+  } else {
+    return false;
+  }
 }
-function allowEmpty(typedef, options) {
-  return options.allowEmpty && typedef.type === 'String';
+function appendEmpty(typedef, options) {
+  if (!options.allowNull) {
+    return false;
+  }
+  const {
+    required,
+    type
+  } = typedef;
+  return !required && type === 'ObjectId';
 }
 function isExcludedField(field, options) {
   if ((0, _utils.isSchemaTypedef)(field)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bedrockio/model",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "description": "Bedrock utilities for model creation.",
   "type": "module",
   "scripts": {
@@ -30,22 +30,22 @@
     "lodash": "^4.17.21"
   },
   "peerDependencies": {
-    "@bedrockio/yada": "^1.1.3",
-    "mongoose": "^8.5.1"
+    "@bedrockio/yada": "^1.2.2",
+    "mongoose": "^8.6.2"
   },
   "devDependencies": {
     "@babel/cli": "^7.20.7",
     "@babel/core": "^7.20.12",
     "@babel/preset-env": "^7.20.2",
     "@bedrockio/prettier-config": "^1.0.2",
-    "@bedrockio/yada": "^1.1.3",
+    "@bedrockio/yada": "^1.2.2",
     "@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": "^8.5.1",
+    "mongoose": "^8.6.2",
     "prettier-eslint": "^15.0.1",
     "typescript": "^4.9.5"
   },

package/src/assign.js

@@ -7,7 +7,7 @@ export 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) {
+      if (value === null || value === '') {
         this.set(path, undefined);
       } else {
         this.set(path, value);

package/src/validation.js

@@ -95,7 +95,7 @@ export function applyValidation(schema, definition) {
         model: this,
         appendSchema,
         allowInclude,
-        allowEmpty: true,
+        stripEmpty: true,
         stripDeleted: true,
         stripTimestamps: true,
         allowDefaultTags: true,
@@ -119,7 +119,7 @@ export function applyValidation(schema, definition) {
         model: this,
         appendSchema,
         allowInclude,
-        allowUnset: true,
+        allowNull: true,
         skipRequired: true,
         stripUnknown: true,
         stripDeleted: true,
@@ -137,22 +137,14 @@ export function applyValidation(schema, definition) {
     }
   );
 
-  schema.static('getDeleteValidation', function getDeleteValidation() {
-    const allowed = definition.access?.delete || 'all';
-    return validateAccess('delete', yd, allowed, {
-      model: this,
-      message: 'You do not have permissions to delete this document.',
-    });
-  });
-
   schema.static(
     'getSearchValidation',
     function getSearchValidation(options = {}) {
       const { defaults, includeDeleted, ...appendSchema } = options;
-
       return getSchemaFromMongoose(schema, {
         model: this,
         allowNull: true,
+        stripEmpty: true,
         allowSearch: true,
         skipRequired: true,
         allowInclude: true,
@@ -169,6 +161,14 @@ export function applyValidation(schema, definition) {
     }
   );
 
+  schema.static('getDeleteValidation', function getDeleteValidation() {
+    const allowed = definition.access?.delete || 'all';
+    return validateAccess('delete', yd, allowed, {
+      model: this,
+      message: 'You do not have permissions to delete this document.',
+    });
+  });
+
   schema.static('getIncludeValidation', function getIncludeValidation() {
     return INCLUDE_FIELD_SCHEMA;
   });
@@ -239,7 +239,7 @@ function getObjectSchema(arg, options) {
   } else if (Array.isArray(arg)) {
     return getArraySchema(arg, options);
   } else if (typeof arg === 'object') {
-    const { stripUnknown, expandDotSyntax } = options;
+    const { stripUnknown, stripEmpty, expandDotSyntax } = options;
     const map = {};
     for (let [key, field] of Object.entries(arg)) {
       if (!isExcludedField(field, options)) {
@@ -254,6 +254,13 @@ function getObjectSchema(arg, options) {
         stripUnknown: true,
       });
     }
+
+    if (stripEmpty) {
+      schema = schema.options({
+        stripEmpty: true,
+      });
+    }
+
     if (expandDotSyntax) {
       schema = schema.options({
         expandDotSyntax: true,
@@ -300,15 +307,24 @@ function getSchemaForTypedef(typedef, options = {}) {
   } else {
     schema = getSchemaForType(type, options);
 
-    // Only allowed for primitive types.
-    if (allowUnset(typedef, options)) {
-      schema = yd.allow(schema, '').nullable();
-    } else if (allowNull(typedef, options)) {
+    // Null may be allowed to unset non-required fields
+    // in an update operation or to search for non-existent
+    // fields in a search operation.
+    if (allowNull(typedef, options)) {
       schema = schema.nullable();
-    } else if (allowEmpty(typedef, options)) {
+    }
+
+    // Empty strings are allowed to unset non-required fields
+    // in an update operation. Technically this should be null,
+    // however empty strings are allowed here as well as they
+    // generally play nicer with front-end components. For
+    // ObjectId fields the empty string must be appended here.
+    if (disallowEmpty(typedef, options)) {
       schema = schema.options({
-        allowEmpty: true,
+        allowEmpty: false,
       });
+    } else if (appendEmpty(typedef, options)) {
+      schema = yd.allow(schema, '');
     }
   }
 
@@ -465,15 +481,31 @@ function isRequired(typedef, options) {
 }
 
 function allowNull(typedef, options) {
-  return options.allowNull && !typedef.required;
+  if (!options.allowNull) {
+    return false;
+  }
+  const { required, type } = typedef;
+  return !required && type !== 'Boolean';
 }
 
-function allowUnset(typedef, options) {
-  return options.allowUnset && !typedef.required;
+function disallowEmpty(typedef, options) {
+  if (!options.allowNull) {
+    return false;
+  }
+  const { type } = typedef;
+  if (type === 'String' || type === 'ObjectId') {
+    return typedef.required;
+  } else {
+    return false;
+  }
 }
 
-function allowEmpty(typedef, options) {
-  return options.allowEmpty && typedef.type === 'String';
+function appendEmpty(typedef, options) {
+  if (!options.allowNull) {
+    return false;
+  }
+  const { required, type } = typedef;
+  return !required && type === 'ObjectId';
 }
 
 function isExcludedField(field, options) {

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;
@@ -68,7 +67,7 @@ export const OBJECT_ID_SCHEMA: {
     eth(): any;
     swift(): any;
     mongo(): any;
-    format(name: any, fn: any): import("@bedrockio/yada/types/TypeSchema").default;
+    format(name: any, fn: any): any;
     toString(): any;
     assertions: any[];
     meta: {};

package/types/validation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.js"],"names":[],"mappings":"AAkFA,kDAEC;AAED,oEAgGC;AAsBD,wEA2BC;AAkTD;;;EAEC;AAED;;;EAOC;AAlhBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQK"}
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.js"],"names":[],"mappings":"AAkFA,kDAEC;AAED,oEAgGC;AAsBD,wEA2BC;AAkVD;;;EAEC;AAED;;;EAOC;AAljBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQK"}