@bedrockio/model 0.1.33 → 0.2.0

package/dist/cjs/soft-delete.js

@@ -6,9 +6,12 @@ Object.defineProperty(exports, "__esModule", {
 exports.applySoftDelete = applySoftDelete;
 exports.assertUnique = assertUnique;
 exports.hasUniqueConstraints = hasUniqueConstraints;
+var _lodash = require("lodash");
+var _query = require("./query");
 function applySoftDelete(schema) {
   applyQueries(schema);
   applyUniqueConstraints(schema);
+  applyHookPatch(schema);
 }
 
 // Soft Delete Querying
@@ -48,124 +51,142 @@ function applyQueries(schema) {
 
   // Static Methods
 
-  schema.static('deleteOne', async function deleteOne(filter, ...rest) {
+  schema.static('deleteOne', function deleteOne(filter, ...rest) {
     const update = getDelete();
-    const res = await this.updateOne(filter, update, ...rest);
-    return {
-      acknowledged: res.acknowledged,
-      deletedCount: res.modifiedCount
-    };
+    const query = this.updateOne(filter, update, ...omitCallback(rest));
+    return (0, _query.wrapQuery)(query, async promise => {
+      const res = await promise;
+      return {
+        acknowledged: res.acknowledged,
+        deletedCount: res.modifiedCount
+      };
+    });
   });
-  schema.static('deleteMany', async function deleteMany(filter, ...rest) {
+  schema.static('deleteMany', function deleteMany(filter, ...rest) {
     const update = getDelete();
-    const res = await this.updateMany(filter, update, ...rest);
-    return {
-      acknowledged: res.acknowledged,
-      deletedCount: res.modifiedCount
-    };
+    const query = this.updateMany(filter, update, ...omitCallback(rest));
+    return (0, _query.wrapQuery)(query, async promise => {
+      const res = await promise;
+      return {
+        acknowledged: res.acknowledged,
+        deletedCount: res.modifiedCount
+      };
+    });
   });
-  schema.static('findOneAndDelete', async function findOneAndDelete(filter, ...args) {
-    return await this.findOneAndUpdate(filter, getDelete(), ...args);
+  schema.static('findOneAndDelete', function findOneAndDelete(filter, ...rest) {
+    return this.findOneAndUpdate(filter, getDelete(), ...omitCallback(rest));
   });
-  schema.static('restoreOne', async function restoreOne(filter, ...rest) {
-    const update = getRestore();
-    const res = await this.updateOne(filter, update, ...rest);
-    return {
-      acknowledged: res.acknowledged,
-      restoredCount: res.modifiedCount
-    };
+  schema.static('restoreOne', function restoreOne(filter, ...rest) {
+    const query = this.updateOne(filter, getRestore(), ...omitCallback(rest));
+    return (0, _query.wrapQuery)(query, async promise => {
+      const res = await promise;
+      return {
+        acknowledged: res.acknowledged,
+        restoredCount: res.modifiedCount
+      };
+    });
   });
-  schema.static('restoreMany', async function restoreMany(filter, ...rest) {
-    const update = getRestore();
-    const res = await this.updateMany(filter, update, ...rest);
-    return {
-      acknowledged: res.acknowledged,
-      restoredCount: res.modifiedCount
-    };
+  schema.static('restoreMany', function restoreMany(filter, ...rest) {
+    const query = this.updateMany(filter, getRestore(), ...omitCallback(rest));
+    return (0, _query.wrapQuery)(query, async promise => {
+      const res = await promise;
+      return {
+        acknowledged: res.acknowledged,
+        restoredCount: res.modifiedCount
+      };
+    });
   });
-  schema.static('destroyOne', async function destroyOne(...args) {
-    const res = await this.collection.deleteOne(...args);
-    return {
-      acknowledged: res.acknowledged,
-      destroyedCount: res.deletedCount
-    };
+  schema.static('destroyOne', function destroyOne(conditions, ...rest) {
+    // Following Mongoose patterns here
+    const query = new this.Query({}, {}, this, this.collection).deleteOne(conditions, ...omitCallback(rest));
+    return (0, _query.wrapQuery)(query, async promise => {
+      const res = await promise;
+      return {
+        acknowledged: res.acknowledged,
+        destroyedCount: res.deletedCount
+      };
+    });
   });
-  schema.static('destroyMany', async function destroyMany(...args) {
-    const res = await this.collection.deleteMany(...args);
-    return {
-      acknowledged: res.acknowledged,
-      destroyedCount: res.deletedCount
-    };
+  schema.static('destroyMany', function destroyMany(conditions, ...rest) {
+    // Following Mongoose patterns here
+    const query = new this.Query({}, {}, this, this.collection).deleteMany(conditions, ...omitCallback(rest));
+    return (0, _query.wrapQuery)(query, async promise => {
+      const res = await promise;
+      return {
+        acknowledged: res.acknowledged,
+        destroyedCount: res.deletedCount
+      };
+    });
   });
   schema.static('findDeleted', function findDeleted(filter, ...rest) {
     filter = {
       ...filter,
       deleted: true
     };
-    return this.find(filter, ...rest);
+    return this.find(filter, ...omitCallback(rest));
   });
   schema.static('findOneDeleted', function findOneDeleted(filter, ...rest) {
     filter = {
       ...filter,
       deleted: true
     };
-    return this.findOne(filter, ...rest);
+    return this.findOne(filter, ...omitCallback(rest));
   });
   schema.static('findByIdDeleted', function findByIdDeleted(id, ...rest) {
     const filter = {
       _id: id,
       deleted: true
     };
-    return this.findOne(filter, ...rest);
+    return this.findOne(filter, ...omitCallback(rest));
   });
   schema.static('existsDeleted', function existsDeleted(filter, ...rest) {
     filter = {
       ...filter,
       deleted: true
     };
-    return this.exists(filter, ...rest);
+    return this.exists(filter, ...omitCallback(rest));
   });
   schema.static('countDocumentsDeleted', function countDocumentsDeleted(filter, ...rest) {
     filter = {
       ...filter,
       deleted: true
     };
-    return this.countDocuments(filter, ...rest);
+    return this.countDocuments(filter, ...omitCallback(rest));
   });
   schema.static('findWithDeleted', function findWithDeleted(filter, ...rest) {
     filter = {
       ...filter,
       ...getWithDeletedQuery()
     };
-    return this.find(filter, ...rest);
+    return this.find(filter, ...omitCallback(rest));
   });
   schema.static('findOneWithDeleted', function findOneWithDeleted(filter, ...rest) {
     filter = {
       ...filter,
       ...getWithDeletedQuery()
     };
-    return this.findOne(filter, ...rest);
+    return this.findOne(filter, ...omitCallback(rest));
   });
   schema.static('findByIdWithDeleted', function findByIdWithDeleted(id, ...rest) {
     const filter = {
       _id: id,
       ...getWithDeletedQuery()
     };
-    return this.findOne(filter, ...rest);
+    return this.findOne(filter, ...omitCallback(rest));
   });
   schema.static('existsWithDeleted', function existsWithDeleted(filter, ...rest) {
     filter = {
       ...filter,
       ...getWithDeletedQuery()
     };
-    return this.exists(filter, ...rest);
+    return this.exists(filter, ...omitCallback(rest));
   });
   schema.static('countDocumentsWithDeleted', function countDocumentsWithDeleted(filter, ...rest) {
     filter = {
       ...filter,
       ...getWithDeletedQuery()
     };
-    return this.countDocuments(filter, ...rest);
+    return this.countDocuments(filter, ...omitCallback(rest));
   });
 }
 function getDelete() {
@@ -368,4 +389,158 @@ function getCollisions(obj1, obj2) {
   return collisions;
 }
 
-// Disallowed Methods
+// Hook Patch
+
+function applyHookPatch(schema) {
+  const schemaPre = schema.pre;
+  const schemaPost = schema.post;
+  schema.pre = function (name, fn) {
+    if (name === 'restore') {
+      // Document hooks
+      schemaPre.call(this, 'save', getPreDocRestore(fn));
+    } else if (name === 'deleteOne') {
+      // Query Hooks
+      schemaPre.call(this, 'updateOne', getPreDelete(fn));
+    } else if (name === 'deleteMany') {
+      schemaPre.call(this, 'updateMany', getPreDelete(fn));
+    } else if (name === 'findOneAndDelete') {
+      schemaPre.call(this, 'findOneAndUpdate', getPreDelete(fn));
+    } else if (name === 'restoreOne') {
+      schemaPre.call(this, 'updateOne', getPreRestore(fn));
+    } else if (name === 'restoreMany') {
+      schemaPre.call(this, 'updateMany', getPreRestore(fn));
+    } else if (name === 'destroyOne') {
+      schemaPre.call(this, 'deleteOne', getPre(fn));
+    } else if (name === 'destroyMany') {
+      schemaPre.call(this, 'deleteMany', getPre(fn));
+    } else if (name === 'findDeleted') {
+      schemaPre.call(this, 'find', getPreDeleted(fn));
+    } else if (name === 'findOneDeleted') {
+      schemaPre.call(this, 'findOne', getPreDeleted(fn));
+    } else if (name === 'countDocumentsDeleted') {
+      schemaPre.call(this, 'countDocuments', getPreDeleted(fn));
+    } else if (name === 'findWithDeleted') {
+      schemaPre.call(this, 'find', getPreWithDeleted(fn));
+    } else if (name === 'findOneWithDeleted') {
+      schemaPre.call(this, 'findOne', getPreWithDeleted(fn));
+    } else if (name === 'countDocumentsWithDeleted') {
+      schemaPre.call(this, 'countDocuments', getPreWithDeleted(fn));
+    } else {
+      schemaPre.apply(this, arguments);
+    }
+    return this;
+  };
+  schema.post = function (name, fn) {
+    if (name === 'deleteOne') {
+      schemaPost.call(this, 'updateOne', getPostDelete(fn));
+    } else if (name === 'deleteMany') {
+      schemaPost.call(this, 'updateMany', getPostDelete(fn));
+    } else if (name === 'findOneAndDelete') {
+      schemaPost.call(this, 'findOneAndUpdate', getPostDelete(fn));
+    } else if (name === 'restoreOne') {
+      schemaPost.call(this, 'updateOne', getPostRestore(fn));
+    } else if (name === 'restoreMany') {
+      schemaPost.call(this, 'updateMany', getPostRestore(fn));
+    } else if (name === 'destroyOne') {
+      schemaPost.call(this, 'deleteOne', getPost(fn));
+    } else if (name === 'destroyMany') {
+      schemaPost.call(this, 'deleteMany', getPost(fn));
+    } else if (name === 'findDeleted') {
+      schemaPost.call(this, 'find', getPostDeleted(fn));
+    } else if (name === 'findOneDeleted') {
+      schemaPost.call(this, 'findOne', getPostDeleted(fn));
+    } else if (name === 'countDocumentsDeleted') {
+      schemaPost.call(this, 'countDocuments', getPostDeleted(fn));
+    } else if (name === 'findWithDeleted') {
+      schemaPost.call(this, 'find', getPostWithDeleted(fn));
+    } else if (name === 'findOneWithDeleted') {
+      schemaPost.call(this, 'findOne', getPostWithDeleted(fn));
+    } else if (name === 'countDocumentsWithDeleted') {
+      schemaPost.call(this, 'countDocuments', getPostWithDeleted(fn));
+    } else {
+      schemaPost.apply(this, arguments);
+    }
+    return this;
+  };
+}
+
+// Needs to be separated as hooks check arity to
+// determine the arguments to pass.
+
+function getPre(fn, check) {
+  return function (next) {
+    runHook(this, fn, check, next, arguments);
+  };
+}
+function getPost(fn, check) {
+  return function (res, next) {
+    runHook(this, fn, check, next, arguments);
+  };
+}
+function runHook(query, fn, check, next, args) {
+  if (!check || check(query)) {
+    const ret = fn.apply(query, args);
+    if (ret instanceof Promise) {
+      ret.finally(next);
+    }
+  } else {
+    next();
+  }
+}
+function getPreDelete(fn) {
+  return getPre(fn, query => {
+    return query.get('deleted') === true;
+  });
+}
+function getPreRestore(fn) {
+  return getPre(fn, query => {
+    return query.get('deleted') === false;
+  });
+}
+function getPreDeleted(fn) {
+  return getPre(fn, query => {
+    return query.getFilter().deleted === true;
+  });
+}
+function getPreWithDeleted(fn) {
+  return getPre(fn, query => {
+    return (0, _lodash.isEqual)(query.getFilter().deleted, getWithDeletedQuery().deleted);
+  });
+}
+function getPreDocRestore(fn) {
+  return getPre(fn, doc => {
+    return doc.isModified('deleted') && doc.deleted === false;
+  });
+}
+function getPostDelete(fn) {
+  return getPost(fn, query => {
+    return query.get('deleted') === true;
+  });
+}
+function getPostRestore(fn) {
+  return getPost(fn, query => {
+    return query.get('deleted') === false;
+  });
+}
+function getPostDeleted(fn) {
+  return getPost(fn, query => {
+    return query.getFilter().deleted === true;
+  });
+}
+function getPostWithDeleted(fn) {
+  return getPost(fn, query => {
+    return (0, _lodash.isEqual)(query.getFilter().deleted, getWithDeletedQuery().deleted);
+  });
+}
+
+// Utils
+
+// Mongoose >= v7 no longer accepts a callback for queries,
+// however it still passes post hooks to static methods for
+// some reason (this appears to be a bug), so omit functions
+// here to allow projectsion/options to still be passed.
+function omitCallback(args) {
+  return args.filter(arg => {
+    return typeof arg !== 'function';
+  });
+}

package/dist/cjs/validation.js

@@ -23,11 +23,10 @@ const DATE_TAGS = {
   '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_SCHEMA = _yada.default.string().mongo().message('Must be an ObjectId.').tag({
+const OBJECT_ID_SCHEMA = exports.OBJECT_ID_SCHEMA = _yada.default.string().mongo().message('Must be an ObjectId.').tag({
   'x-schema': 'ObjectId',
   'x-description': 'A 24 character hexadecimal string representing a Mongo [ObjectId](https://bit.ly/3YPtGlU).'
 });
-exports.OBJECT_ID_SCHEMA = OBJECT_ID_SCHEMA;
 const REFERENCE_SCHEMA = _yada.default.allow(OBJECT_ID_SCHEMA, _yada.default.object({
   id: OBJECT_ID_SCHEMA.required()
 }).options({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bedrockio/model",
-  "version": "0.1.33",
+  "version": "0.2.0",
   "description": "Bedrock utilities for model creation.",
   "type": "module",
   "scripts": {
@@ -30,7 +30,7 @@
   },
   "peerDependencies": {
     "@bedrockio/yada": "^1.0.33",
-    "mongoose": ">=6.9.0"
+    "mongoose": "^6.9.0 || ^7.6.4"
   },
   "devDependencies": {
     "@babel/cli": "^7.20.7",
@@ -38,14 +38,14 @@
     "@babel/preset-env": "^7.20.2",
     "@bedrockio/prettier-config": "^1.0.2",
     "@bedrockio/yada": "^1.0.33",
-    "@shelf/jest-mongodb": "^4.1.6",
+    "@shelf/jest-mongodb": "^4.1.7",
     "babel-plugin-import-replacement": "^1.0.1",
     "eslint": "^8.33.0",
     "eslint-plugin-bedrock": "^1.0.26",
     "jest": "^29.4.1",
     "jest-environment-node": "^29.4.1",
-    "mongodb": "4.13.0",
-    "mongoose": "^6.9.0",
+    "mongodb": "^5.9.1",
+    "mongoose": "^7.6.4",
     "prettier-eslint": "^15.0.1",
     "typescript": "^4.9.5"
   },