@bedrockio/model 0.1.0 → 0.1.2

package/dist/cjs/soft-delete.js

@@ -4,9 +4,16 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.applySoftDelete = applySoftDelete;
-var _warn = _interopRequireDefault(require("./warn"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+exports.assertUnique = assertUnique;
+exports.hasUniqueConstraints = hasUniqueConstraints;
 function applySoftDelete(schema) {
+  applyQueries(schema);
+  applyUniqueConstraints(schema);
+}
+
+// Soft Delete Querying
+
+function applyQueries(schema) {
   // Implementation
 
   schema.pre(/^find|count|exists/, function (next) {
@@ -23,11 +30,13 @@ function applySoftDelete(schema) {
   schema.method('delete', function () {
     this.deleted = true;
     this.deletedAt = new Date();
+    // @ts-ignore
     return this.save();
   });
   schema.method('restore', function restore() {
     this.deleted = false;
     this.deletedAt = undefined;
+    // @ts-ignore
     return this.save();
   });
   schema.method('destroy', function destroy(...args) {
@@ -88,85 +97,75 @@ function applySoftDelete(schema) {
       destroyedCount: res.deletedCount
     };
   });
-  schema.static('findDeleted', function findDeleted(filter) {
-    return this.find({
+  schema.static('findDeleted', function findDeleted(filter, ...rest) {
+    filter = {
       ...filter,
       deleted: true
-    });
+    };
+    return this.find(filter, ...rest);
   });
-  schema.static('findOneDeleted', function findOneDeleted(filter) {
-    return this.findOne({
+  schema.static('findOneDeleted', function findOneDeleted(filter, ...rest) {
+    filter = {
       ...filter,
       deleted: true
-    });
+    };
+    return this.findOne(filter, ...rest);
   });
-  schema.static('findByIdDeleted', function findByIdDeleted(id) {
-    return this.findOne({
+  schema.static('findByIdDeleted', function findByIdDeleted(id, ...rest) {
+    const filter = {
       _id: id,
       deleted: true
-    });
+    };
+    return this.findOne(filter, ...rest);
   });
-  schema.static('existsDeleted', function existsDeleted() {
-    return this.exists({
+  schema.static('existsDeleted', function existsDeleted(filter, ...rest) {
+    filter = {
+      ...filter,
       deleted: true
-    });
+    };
+    return this.exists(filter, ...rest);
   });
-  schema.static('countDocumentsDeleted', function countDocumentsDeleted(filter) {
-    return this.countDocuments({
+  schema.static('countDocumentsDeleted', function countDocumentsDeleted(filter, ...rest) {
+    filter = {
       ...filter,
       deleted: true
-    });
+    };
+    return this.countDocuments(filter, ...rest);
   });
-  schema.static('findWithDeleted', function findWithDeleted(filter) {
-    return this.find({
+  schema.static('findWithDeleted', function findWithDeleted(filter, ...rest) {
+    filter = {
       ...filter,
       ...getWithDeletedQuery()
-    });
+    };
+    return this.find(filter, ...rest);
   });
-  schema.static('findOneWithDeleted', function findOneWithDeleted(filter) {
-    return this.findOne({
+  schema.static('findOneWithDeleted', function findOneWithDeleted(filter, ...rest) {
+    filter = {
       ...filter,
       ...getWithDeletedQuery()
-    });
+    };
+    return this.findOne(filter, ...rest);
   });
-  schema.static('findByIdWithDeleted', function findByIdWithDeleted(id) {
-    return this.findOne({
+  schema.static('findByIdWithDeleted', function findByIdWithDeleted(id, ...rest) {
+    const filter = {
       _id: id,
       ...getWithDeletedQuery()
-    });
+    };
+    return this.findOne(filter, ...rest);
   });
-  schema.static('existsWithDeleted', function existsWithDeleted() {
-    return this.exists({
+  schema.static('existsWithDeleted', function existsWithDeleted(filter, ...rest) {
+    filter = {
+      ...filter,
       ...getWithDeletedQuery()
-    });
+    };
+    return this.exists(filter, ...rest);
   });
-  schema.static('countDocumentsWithDeleted', function countDocumentsWithDeleted(filter) {
-    return this.countDocuments({
+  schema.static('countDocumentsWithDeleted', function countDocumentsWithDeleted(filter, ...rest) {
+    filter = {
       ...filter,
       ...getWithDeletedQuery()
-    });
-  });
-  schema.method('remove', function () {
-    (0, _warn.default)('The "remove" method on documents is disallowed due to ambiguity.', 'To permanently delete a document use "destroy", otherwise "delete".');
-    throw new Error('Method not allowed.');
-  }, {
-    suppressWarning: true
-  });
-  schema.method('deleteOne', function () {
-    (0, _warn.default)('The "deleteOne" method on documents is disallowed due to ambiguity', 'Use either "delete" or "deleteOne" on the model.');
-    throw new Error('Method not allowed.');
-  });
-  schema.static('remove', function () {
-    (0, _warn.default)('The "remove" method on models is disallowed due to ambiguity.', 'To permanently delete a document use "destroyMany", otherwise "deleteMany".');
-    throw new Error('Method not allowed.');
-  });
-  schema.static('findOneAndRemove', function () {
-    (0, _warn.default)('The "findOneAndRemove" method on models is disallowed due to ambiguity.', 'To permanently delete a document use "findOneAndDestroy", otherwise "findOneAndDelete".');
-    throw new Error('Method not allowed.');
-  });
-  schema.static('findByIdAndRemove', function () {
-    (0, _warn.default)('The "findByIdAndRemove" method on models is disallowed due to ambiguity.', 'To permanently delete a document use "findByIdAndDestroy", otherwise "findByIdAndDelete".');
-    throw new Error('Method not allowed.');
+    };
+    return this.countDocuments(filter, ...rest);
   });
 }
 function getDelete() {
@@ -189,4 +188,184 @@ function getWithDeletedQuery() {
       $in: [true, false]
     }
   };
-}
+}
+
+// Unique Constraints
+
+function applyUniqueConstraints(schema) {
+  const hasUnique = hasUniqueConstraints(schema);
+  if (!hasUnique) {
+    return;
+  }
+  schema.pre('save', async function () {
+    await assertUnique(this.toObject(), {
+      operation: this.isNew ? 'create' : 'update',
+      model: this.constructor,
+      schema
+    });
+  });
+  schema.pre(/^(update|replace)/, async function () {
+    await assertUniqueForQuery(this, {
+      schema
+    });
+  });
+  schema.pre('insertMany', async function (next, obj) {
+    // Note that in order to access the objects to be inserted
+    // we must supply the hook with at least 2 arguments, the
+    // first of which is the next hook. This typically appears
+    // as the last argument, however as we are passing an async
+    // function it appears to not stop the middleware if we
+    // don't call it directly.
+    await assertUnique(obj, {
+      operation: 'create',
+      model: this,
+      schema
+    });
+  });
+}
+async function assertUnique(obj, options) {
+  const {
+    operation,
+    model,
+    schema
+  } = options;
+  const id = getId(obj);
+  const objFields = resolveUnique(schema, obj);
+  if (Object.keys(objFields).length === 0) {
+    return;
+  }
+  const query = {
+    $or: getUniqueQueries(objFields),
+    ...(id && {
+      _id: {
+        $ne: id
+      }
+    })
+  };
+  const found = await model.findOne(query, {}, {
+    lean: true
+  });
+  if (found) {
+    const {
+      modelName
+    } = model;
+    const foundFields = resolveUnique(schema, found);
+    const collisions = getCollisions(objFields, foundFields).join(', ');
+    throw new Error(`Cannot ${operation} ${modelName}. Duplicate fields exist: ${collisions}.`);
+  }
+}
+function getId(arg) {
+  const id = arg.id || arg._id;
+  return id ? String(id) : null;
+}
+
+// Asserts than an update or insert query will not
+// result in duplicate unique fields being present
+// within non-deleted documents.
+async function assertUniqueForQuery(query, options) {
+  let update = query.getUpdate();
+  const operation = getOperationForQuery(update);
+  // Note: No need to check unique constraints
+  // if the operation is a delete.
+  if (operation === 'restore' || operation === 'update') {
+    const {
+      model
+    } = query;
+    const filter = query.getFilter();
+    if (operation === 'restore') {
+      // A restore operation is functionally identical to a new
+      // insert so we need to fetch the deleted documents with
+      // all fields available to check against.
+      const docs = await model.findWithDeleted(filter, {}, {
+        lean: true
+      });
+      update = docs.map(doc => {
+        return {
+          ...doc,
+          ...update
+        };
+      });
+    }
+    await assertUnique(update, {
+      ...options,
+      operation,
+      model
+    });
+  }
+}
+function getOperationForQuery(update) {
+  if (update?.deleted === false) {
+    return 'restore';
+  } else if (update?.deleted === true) {
+    return 'delete';
+  } else {
+    return 'update';
+  }
+}
+function hasUniqueConstraints(schema) {
+  const paths = [...Object.keys(schema.paths), ...Object.keys(schema.subpaths)];
+  return paths.some(key => {
+    return isUniquePath(schema, key);
+  });
+}
+function isUniquePath(schema, key) {
+  return schema.path(key)?.options?.softUnique === true;
+}
+
+// Returns a flattened map of key -> [...values]
+// consisting of only paths defined as unique on the schema.
+function resolveUnique(schema, obj, map = {}, path = []) {
+  if (Array.isArray(obj)) {
+    for (let el of obj) {
+      resolveUnique(schema, el, map, path);
+    }
+  } else if (obj && typeof obj === 'object') {
+    for (let [key, val] of Object.entries(obj)) {
+      resolveUnique(schema, val, map, [...path, key]);
+    }
+  } else if (obj) {
+    const key = path.join('.');
+    if (isUniquePath(schema, key)) {
+      map[key] ||= [];
+      map[key].push(obj);
+    }
+  }
+  return map;
+}
+
+// Argument is guaranteed to be flattened.
+function getUniqueQueries(obj) {
+  return Object.entries(obj).map(([key, val]) => {
+    if (val.length > 1) {
+      return {
+        [key]: {
+          $in: val
+        }
+      };
+    } else {
+      return {
+        [key]: val[0]
+      };
+    }
+  });
+}
+
+// Both arguments here are guaranteed to be flattened
+// maps of key -> [values] of unique fields only.
+function getCollisions(obj1, obj2) {
+  const collisions = [];
+  for (let [key, arr1] of Object.entries(obj1)) {
+    const arr2 = obj2[key];
+    if (arr2) {
+      const hasCollision = arr1.some(val => {
+        return arr2.includes(val);
+      });
+      if (hasCollision) {
+        collisions.push(key);
+      }
+    }
+  }
+  return collisions;
+}
+
+// Disallowed Methods

package/dist/cjs/testing.js

@@ -10,6 +10,14 @@ var _schema = require("./schema");
 var _utils = require("./utils");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 let counter = 0;
+
+/**
+ * Helper to quickly create models for testing.
+ * Accepts a definition's `attributes` object and
+ * an optional model name as the first argument.
+ * [Link](https://github.com/bedrockio/model#testing)
+ * @returns mongoose.Model
+ */
 function createTestModel(...args) {
   let modelName, attributes, schema;
   if (typeof args[0] === 'string') {

package/dist/cjs/validation.js

@@ -3,29 +3,47 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.OBJECT_ID_SCHEMA = void 0;
 exports.addValidators = addValidators;
 exports.applyValidation = applyValidation;
 exports.getNamedValidator = getNamedValidator;
 exports.getTupleValidator = getTupleValidator;
 exports.getValidationSchema = getValidationSchema;
-var _lowerFirst2 = _interopRequireDefault(require("lodash/lowerFirst"));
-var _omit2 = _interopRequireDefault(require("lodash/omit"));
-var _get2 = _interopRequireDefault(require("lodash/get"));
 var _mongoose = _interopRequireDefault(require("mongoose"));
 var _yada = _interopRequireDefault(require("@bedrockio/yada"));
+var _lodash = require("lodash");
 var _access = require("./access");
 var _search = require("./search");
 var _errors = require("./errors");
+var _softDelete = require("./soft-delete");
 var _utils = require("./utils");
 var _schema = require("./schema");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const DATE_SCHEMA = _yada.default.date().iso().tag({
+  'x-schema': 'DateTime',
+  'x-description': 'A `string` in [ISO 8601](https://www.iso.org/iso-8601-date-and-time-format.html) format.'
+});
+const OBJECT_ID_DESCRIPTION = `
+A 24 character hexadecimal string representing a Mongo [ObjectId](https://bit.ly/3YPtGlU).
+An object with an \`id\` field may also be passed, which will be converted into a string.
+`;
+const OBJECT_ID_SCHEMA = _yada.default.custom(async val => {
+  const id = String(val.id || val);
+  await namedSchemas.objectId.validate(id);
+  return id;
+}).tag({
+  type: 'ObjectId',
+  'x-schema': 'ObjectId',
+  'x-description': OBJECT_ID_DESCRIPTION.trim()
+});
+exports.OBJECT_ID_SCHEMA = OBJECT_ID_SCHEMA;
 const namedSchemas = {
   // Email is special as we are assuming that in
   // all cases lowercase should be allowed but coerced.
   email: _yada.default.string().lowercase().email(),
-  // Force "ObjectId" to have parity with refs.
+  // Force "objectId" to have parity with refs.
   // "mongo" is notably excluded here for this reason.
-  ObjectId: _yada.default.string().mongo(),
+  objectId: _yada.default.string().mongo(),
   ascii: _yada.default.string().ascii(),
   base64: _yada.default.string().base64(),
   btc: _yada.default.string().btc(),
@@ -51,45 +69,60 @@ function addValidators(schemas) {
   Object.assign(namedSchemas, schemas);
 }
 function applyValidation(schema, definition) {
+  const hasUnique = (0, _softDelete.hasUniqueConstraints)(schema);
   schema.static('getCreateValidation', function getCreateValidation(appendSchema) {
     return getSchemaFromMongoose(schema, {
+      model: this,
       appendSchema,
       stripReserved: true,
       requireWriteAccess: true,
-      modelName: this.modelName
+      ...(hasUnique && {
+        assertUniqueOptions: {
+          schema,
+          operation: 'create'
+        }
+      })
     });
   });
   schema.static('getUpdateValidation', function getUpdateValidation(appendSchema) {
     return getSchemaFromMongoose(schema, {
+      model: this,
       appendSchema,
       skipRequired: true,
       stripReserved: true,
       stripUnknown: true,
       requireWriteAccess: true,
-      modelName: this.modelName
+      ...(hasUnique && {
+        assertUniqueOptions: {
+          schema,
+          operation: 'update'
+        }
+      })
     });
   });
   schema.static('getSearchValidation', function getSearchValidation(searchOptions) {
     return getSchemaFromMongoose(schema, {
-      allowRanges: true,
+      allowSearch: true,
       skipRequired: true,
-      allowMultiple: true,
       unwindArrayFields: true,
       requireReadAccess: true,
       appendSchema: (0, _search.searchValidation)(definition, searchOptions),
-      modelName: this.modelName
+      model: this
     });
   });
+  schema.static('getBaseSchema', function getBaseSchema() {
+    return getSchemaFromMongoose(schema);
+  });
 }
 
 // Yada schemas
 
-function getSchemaFromMongoose(schema, options) {
+function getSchemaFromMongoose(schema, options = {}) {
   let {
     obj
   } = schema;
   if (options.stripReserved) {
-    obj = (0, _omit2.default)(obj, _schema.RESERVED_FIELDS);
+    obj = (0, _lodash.omit)(obj, _schema.RESERVED_FIELDS);
   }
   return getValidationSchema(obj, options);
 }
@@ -97,9 +130,18 @@ function getSchemaFromMongoose(schema, options) {
 // Exported for testing
 function getValidationSchema(attributes, options = {}) {
   const {
-    appendSchema
+    appendSchema,
+    assertUniqueOptions
   } = options;
   let schema = getObjectSchema(attributes, options);
+  if (assertUniqueOptions) {
+    schema = _yada.default.custom(async obj => {
+      await (0, _softDelete.assertUnique)(obj, {
+        model: options.model,
+        ...assertUniqueOptions
+      });
+    });
+  }
   if (appendSchema) {
     schema = schema.append(appendSchema);
   }
@@ -164,6 +206,8 @@ function getSchemaForTypedef(typedef, options = {}) {
   }
   if (typedef.validate?.schema) {
     schema = schema.append(typedef.validate.schema);
+  } else if (typeof typedef.validate === 'function') {
+    schema = schema.custom(wrapMongooseValidator(typedef.validate));
   }
   if (typedef.enum) {
     schema = schema.allow(...typedef.enum);
@@ -177,11 +221,8 @@ function getSchemaForTypedef(typedef, options = {}) {
   if (typedef.max != null || typedef.maxLength != null) {
     schema = schema.max(typedef.max ?? typedef.maxLength);
   }
-  if (options.allowRanges) {
-    schema = getRangeSchema(schema, type);
-  }
-  if (options.allowMultiple) {
-    schema = _yada.default.allow(schema, _yada.default.array(schema));
+  if (options.allowSearch) {
+    schema = getSearchSchema(schema, type);
   }
   if (typedef.readAccess && options.requireReadAccess) {
     schema = validateReadAccess(schema, typedef.readAccess, options);
@@ -200,39 +241,56 @@ function getSchemaForType(type) {
     case 'Boolean':
       return _yada.default.boolean();
     case 'Date':
-      return _yada.default.date().iso();
+      return DATE_SCHEMA;
     case 'Mixed':
     case 'Object':
       return _yada.default.object();
     case 'Array':
       return _yada.default.array();
     case 'ObjectId':
-      return _yada.default.custom(async val => {
-        const id = String(val.id || val);
-        await namedSchemas['ObjectId'].validate(id);
-        return id;
-      });
+      return OBJECT_ID_SCHEMA;
     default:
       throw new TypeError(`Unknown schema type ${type}`);
   }
 }
-function getRangeSchema(schema, type) {
+function getSearchSchema(schema, type) {
   if (type === 'Number') {
-    schema = _yada.default.allow(schema, _yada.default.object({
-      lt: _yada.default.number(),
-      gt: _yada.default.number(),
-      lte: _yada.default.number(),
-      gte: _yada.default.number()
-    }));
+    return _yada.default.allow(schema, _yada.default.array(schema), _yada.default.object({
+      lt: _yada.default.number().description('Select values less than.'),
+      gt: _yada.default.number().description('Select values greater than.'),
+      lte: _yada.default.number().description('Select values less than or equal.'),
+      gte: _yada.default.number().description('Select values greater than or equal.')
+    }).tag({
+      'x-schema': 'NumberRange',
+      'x-description': 'An object representing numbers falling within a range.'
+    })).description('Allows searching by a value, array of values, or a numeric range.');
   } else if (type === 'Date') {
-    return _yada.default.allow(schema, _yada.default.object({
-      lt: _yada.default.date().iso(),
-      gt: _yada.default.date().iso(),
-      lte: _yada.default.date().iso(),
-      gte: _yada.default.date().iso()
-    }));
+    return _yada.default.allow(schema, _yada.default.array(schema), _yada.default.object({
+      lt: _yada.default.date().iso().tag({
+        'x-ref': 'DateTime',
+        description: 'Select dates occurring before.'
+      }),
+      gt: _yada.default.date().iso().tag({
+        'x-ref': 'DateTime',
+        description: 'Select dates occurring after.'
+      }),
+      lte: _yada.default.date().iso().tag({
+        'x-ref': 'DateTime',
+        description: 'Select dates occurring on or before.'
+      }),
+      gte: _yada.default.date().iso().tag({
+        'x-ref': 'DateTime',
+        description: 'Select dates occurring on or after.'
+      })
+    }).tag({
+      'x-schema': 'DateRange',
+      'x-description': 'An object representing dates falling within a range.'
+    })).description('Allows searching by a date, array of dates, or a range.');
+  } else if (type === 'String' || type === 'ObjectId') {
+    return _yada.default.allow(schema, _yada.default.array(schema));
+  } else {
+    return schema;
   }
-  return schema;
 }
 function isRequired(typedef, options) {
   return typedef.required && !typedef.default && !options.skipRequired;
@@ -256,15 +314,15 @@ function validateWriteAccess(schema, allowed, options) {
 function validateAccess(type, schema, allowed, options) {
   const {
     modelName
-  } = options;
+  } = options.model;
   return schema.custom((val, options) => {
-    const document = options[(0, _lowerFirst2.default)(modelName)] || options['document'];
+    const document = options[(0, _lodash.lowerFirst)(modelName)] || options['document'];
     const isAllowed = (0, _access.hasAccess)(type, allowed, {
       ...options,
       document
     });
     if (!isAllowed) {
-      const currentValue = (0, _get2.default)(document, options.path);
+      const currentValue = (0, _lodash.get)(document, options.path);
       if (val !== currentValue) {
         throw new _errors.PermissionsError('requires write permissions.');
       }
@@ -275,13 +333,13 @@ function validateAccess(type, schema, allowed, options) {
 // Mongoose Validators
 
 function getNamedValidator(name) {
-  return wrapMongooseValidator(getNamedSchema(name));
+  return wrapSchemaAsValidator(getNamedSchema(name));
 }
 function getTupleValidator(types) {
   types = types.map(type => {
     return getSchemaForTypedef(type);
   });
-  return wrapMongooseValidator(_yada.default.array(types).length(types.length));
+  return wrapSchemaAsValidator(_yada.default.array(types).length(types.length));
 }
 
 // Returns an async function that will error on failure.
@@ -297,13 +355,21 @@ function getTupleValidator(types) {
 // the first style here.
 //
 // https://mongoosejs.com/docs/api/schematype.html#schematype_SchemaType-validate
-function wrapMongooseValidator(schema) {
+function wrapSchemaAsValidator(schema) {
   const validator = async val => {
     await schema.validate(val);
   };
   validator.schema = schema;
   return validator;
 }
+function wrapMongooseValidator(validator) {
+  return async val => {
+    const result = await validator(val);
+    if (!result && result !== undefined) {
+      throw new Error('Validation failed.');
+    }
+  };
+}
 function getNamedSchema(name) {
   const schema = namedSchemas[name];
   if (!schema) {