@bedrockio/model 0.1.33 → 0.2.1

package/dist/cjs/const.js

@@ -4,13 +4,11 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.SEARCH_DEFAULTS = exports.POPULATE_MAX_DEPTH = void 0;
-const SEARCH_DEFAULTS = {
+const SEARCH_DEFAULTS = exports.SEARCH_DEFAULTS = {
   limit: 50,
   sort: {
     field: 'createdAt',
     order: 'desc'
   }
 };
-exports.SEARCH_DEFAULTS = SEARCH_DEFAULTS;
-const POPULATE_MAX_DEPTH = 5;
-exports.POPULATE_MAX_DEPTH = POPULATE_MAX_DEPTH;
+const POPULATE_MAX_DEPTH = exports.POPULATE_MAX_DEPTH = 5;

package/dist/cjs/delete-hooks.js

@@ -0,0 +1,351 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.applyDeleteHooks = applyDeleteHooks;
+var _mongoose = _interopRequireDefault(require("mongoose"));
+var _lodash = require("lodash");
+var _errors = require("./errors");
+var _utils = require("./utils");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const {
+  ObjectId: SchemaObjectId
+} = _mongoose.default.Schema.Types;
+function applyDeleteHooks(schema, definition) {
+  let {
+    onDelete: deleteHooks
+  } = definition;
+  if (!deleteHooks) {
+    return;
+  }
+  const cleanLocal = validateCleanLocal(deleteHooks, schema);
+  const cleanForeign = validateCleanForeign(deleteHooks);
+  const errorHook = validateError(deleteHooks);
+  let references;
+  const deleteFn = schema.methods.delete;
+  const restoreFn = schema.methods.restore;
+  schema.method('delete', async function () {
+    if (errorHook) {
+      references ||= getAllReferences(this);
+      await errorOnForeignReferences(this, {
+        errorHook,
+        cleanForeign,
+        references
+      });
+    }
+    try {
+      await deleteLocalReferences(this, cleanLocal);
+      await deleteForeignReferences(this, cleanForeign);
+    } catch (error) {
+      await restoreLocalReferences(this, cleanLocal);
+      await restoreForeignReferences(this);
+      throw error;
+    }
+    await deleteFn.apply(this, arguments);
+  });
+  schema.method('restore', async function () {
+    await restoreLocalReferences(this, cleanLocal);
+    await restoreForeignReferences(this);
+    await restoreFn.apply(this, arguments);
+  });
+  schema.add({
+    deletedRefs: [{
+      _id: 'ObjectId',
+      ref: 'String'
+    }]
+  });
+}
+
+// Clean Hook
+
+function validateCleanLocal(deleteHooks, schema) {
+  let {
+    local
+  } = deleteHooks.clean || {};
+  if (!local) {
+    return;
+  }
+  if (typeof local !== 'string' && !Array.isArray(local)) {
+    throw new Error('Local delete hook must be an array.');
+  }
+  if (typeof local === 'string') {
+    local = [local];
+  }
+  for (let name of local) {
+    const pathType = schema.pathType(name);
+    if (pathType !== 'real') {
+      throw new Error(`Delete hook has invalid local reference "${name}".`);
+    }
+  }
+  return local;
+}
+function validateCleanForeign(deleteHooks) {
+  const {
+    foreign
+  } = deleteHooks.clean || {};
+  if (!foreign) {
+    return;
+  }
+  if (typeof foreign !== 'object') {
+    throw new Error('Foreign delete hook must be an object.');
+  }
+  for (let [modelName, arg] of Object.entries(foreign)) {
+    if (typeof arg === 'object') {
+      const {
+        $and,
+        $or
+      } = arg;
+      if ($and && $or) {
+        throw new Error(`Cannot define both $or and $and in a delete hook for model ${modelName}.`);
+      }
+    }
+  }
+  return foreign;
+}
+function validateError(deleteHooks) {
+  let {
+    errorOnReferenced
+  } = deleteHooks;
+  if (!errorOnReferenced) {
+    return;
+  }
+  if (errorOnReferenced === true) {
+    errorOnReferenced = {};
+  }
+  return errorOnReferenced;
+}
+
+// Error on references
+
+async function errorOnForeignReferences(doc, options) {
+  const {
+    errorHook,
+    cleanForeign,
+    references
+  } = options;
+  if (!errorHook) {
+    return;
+  }
+  const {
+    only,
+    except
+  } = errorHook;
+  assertModelNames(only);
+  assertModelNames(except);
+  const results = [];
+  for (let {
+    model,
+    paths
+  } of references) {
+    if (referenceIsAllowed(errorHook, model)) {
+      continue;
+    }
+    const $or = paths.filter(path => {
+      if (cleanForeign) {
+        return cleanForeign[model.modelName] !== path;
+      }
+      return true;
+    }).map(path => {
+      return {
+        [path]: doc.id
+      };
+    });
+    if (!$or.length) {
+      continue;
+    }
+    const docs = await model.find({
+      $or
+    }, {
+      _id: 1
+    }).lean();
+    if (docs.length > 0) {
+      const ids = docs.map(doc => {
+        return String(doc._id);
+      });
+      results.push({
+        ids,
+        model,
+        count: ids.length
+      });
+    }
+  }
+  if (results.length) {
+    const {
+      modelName
+    } = doc.constructor;
+    const refNames = results.map(reference => {
+      return reference.model.modelName;
+    });
+    throw new _errors.ReferenceError(`Refusing to delete ${modelName} referenced by ${refNames}.`, results);
+  }
+}
+function referenceIsAllowed(errorHook, model) {
+  const {
+    only,
+    except
+  } = errorHook;
+  if (only) {
+    return !only.includes(model.modelName);
+  } else if (except) {
+    return except.includes(model.modelName);
+  } else {
+    return false;
+  }
+}
+function assertModelNames(arr = []) {
+  for (let val of arr) {
+    if (!_mongoose.default.models[val]) {
+      throw new Error(`Unknown model "${val}".`);
+    }
+  }
+}
+function getAllReferences(doc) {
+  const targetName = doc.constructor.modelName;
+  return Object.values(_mongoose.default.models).map(model => {
+    const paths = getModelReferences(model, targetName);
+    return {
+      model,
+      paths
+    };
+  }).filter(({
+    paths
+  }) => {
+    return paths.length > 0;
+  });
+}
+function getModelReferences(model, targetName) {
+  const paths = [];
+  model.schema.eachPath((schemaPath, schemaType) => {
+    if (schemaType instanceof SchemaObjectId && schemaPath[0] !== '_') {
+      const {
+        ref,
+        refPath
+      } = schemaType.options;
+      let refs;
+      if (ref) {
+        refs = [ref];
+      } else if (refPath) {
+        refs = model.schema.path(refPath).options.enum;
+      } else {
+        throw new Error(`Cannot derive refs for ${model.modelName}#${schemaPath}.`);
+      }
+      if (refs.includes(targetName)) {
+        paths.push(schemaPath);
+      }
+    }
+  });
+  return paths;
+}
+
+// Deletion
+
+async function deleteLocalReferences(doc, arr) {
+  if (!arr) {
+    return;
+  }
+  for (let name of arr) {
+    await doc.populate(name);
+    const value = doc.get(name);
+    const arr = Array.isArray(value) ? value : [value];
+    for (let sub of arr) {
+      await sub.delete();
+    }
+  }
+}
+async function deleteForeignReferences(doc, refs) {
+  if (!refs) {
+    return;
+  }
+  const {
+    id
+  } = doc;
+  if (!id) {
+    throw new Error(`Refusing to apply delete hook to document without id.`);
+  }
+  for (let [modelName, arg] of Object.entries(refs)) {
+    const Model = _mongoose.default.models[modelName];
+    if (typeof arg === 'string') {
+      await runDeletes(Model, doc, {
+        [arg]: id
+      });
+    } else {
+      const {
+        $and,
+        $or
+      } = arg;
+      if ($and) {
+        await runDeletes(Model, doc, {
+          $and: mapArrayQuery($and, id)
+        });
+      } else if ($or) {
+        await runDeletes(Model, doc, {
+          $or: mapArrayQuery($or, id)
+        });
+      }
+    }
+  }
+}
+async function runDeletes(Model, refDoc, query) {
+  const docs = await Model.find(query);
+  for (let doc of docs) {
+    await doc.delete();
+    refDoc.deletedRefs.push({
+      _id: doc.id,
+      ref: doc.constructor.modelName
+    });
+  }
+}
+function mapArrayQuery(arr, id) {
+  return arr.map(refName => {
+    return {
+      [refName]: id
+    };
+  });
+}
+
+// Restore
+
+async function restoreLocalReferences(refDoc, arr) {
+  if (!arr) {
+    return;
+  }
+  for (let name of arr) {
+    const {
+      ref
+    } = (0, _utils.getInnerField)(refDoc.constructor.schema.obj, name);
+    const value = refDoc.get(name);
+    const ids = Array.isArray(value) ? value : [value];
+    const Model = _mongoose.default.models[ref];
+
+    // @ts-ignore
+    const docs = await Model.findDeleted({
+      _id: {
+        $in: ids
+      }
+    });
+    for (let doc of docs) {
+      await doc.restore();
+    }
+  }
+}
+async function restoreForeignReferences(refDoc) {
+  const grouped = (0, _lodash.groupBy)(refDoc.deletedRefs, 'ref');
+  for (let [modelName, refs] of Object.entries(grouped)) {
+    const ids = refs.map(ref => {
+      return ref._id;
+    });
+    const Model = _mongoose.default.models[modelName];
+
+    // @ts-ignore
+    const docs = await Model.findDeleted({
+      _id: {
+        $in: ids
+      }
+    });
+    for (let doc of docs) {
+      await doc.restore();
+    }
+  }
+  refDoc.deletedRefs = [];
+}

package/dist/cjs/disallowed.js

@@ -7,24 +7,10 @@ exports.applyDisallowed = applyDisallowed;
 var _warn = _interopRequireDefault(require("./warn"));
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 function applyDisallowed(schema) {
-  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('update', function () {
-    (0, _warn.default)('The "update" method on documents is deprecated. Use "updateOne" instead.');
-    throw new Error('Method not allowed.');
-  });
   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.');

package/dist/cjs/env.js

@@ -4,5 +4,4 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.debug = void 0;
-const debug = !!process.env.DEBUG;
-exports.debug = debug;
+const debug = exports.debug = !!process.env.DEBUG;

package/dist/cjs/include.js

@@ -24,10 +24,9 @@ _mongoose.default.Query.prototype.include = function include(arg) {
   return this;
 };
 const DESCRIPTION = 'Field to be selected or populated.';
-const INCLUDE_FIELD_SCHEMA = _yada.default.object({
+const INCLUDE_FIELD_SCHEMA = exports.INCLUDE_FIELD_SCHEMA = _yada.default.object({
   include: _yada.default.allow(_yada.default.string().description(DESCRIPTION), _yada.default.array(_yada.default.string().description(DESCRIPTION)))
 });
-exports.INCLUDE_FIELD_SCHEMA = INCLUDE_FIELD_SCHEMA;
 function applyInclude(schema) {
   // Query Includes
 

package/dist/cjs/query.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.wrapQuery = wrapQuery;
+// Wrapper that allows a mongoose query object to be returned
+// to access chained methods while still resolving with a
+// transformed value. Allows methods to behave like other find
+// methods and importantly allow custom population with the same API.
+function wrapQuery(query, fn) {
+  const runQuery = query.then.bind(query);
+  query.then = async (resolve, reject) => {
+    try {
+      resolve(await fn(runQuery()));
+    } catch (err) {
+      reject(err);
+    }
+  };
+  return query;
+}

package/dist/cjs/schema.js

@@ -13,8 +13,8 @@ var _slug = require("./slug");
 var _search = require("./search");
 var _assign = require("./assign");
 var _include = require("./include");
-var _references = require("./references");
 var _softDelete = require("./soft-delete");
+var _deleteHooks = require("./delete-hooks");
 var _disallowed = require("./disallowed");
 var _validation = require("./validation");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
@@ -45,10 +45,13 @@ function createSchema(definition, options = {}) {
     toObject: _serialization.serializeOptions,
     ...options
   });
+
+  // Soft Delete needs to be applied
+  // first for hooks to work correctly.
+  (0, _softDelete.applySoftDelete)(schema);
   (0, _validation.applyValidation)(schema, definition);
+  (0, _deleteHooks.applyDeleteHooks)(schema, definition);
   (0, _search.applySearch)(schema, definition);
-  (0, _softDelete.applySoftDelete)(schema);
-  (0, _references.applyReferences)(schema);
   (0, _disallowed.applyDisallowed)(schema);
   (0, _include.applyInclude)(schema);
   (0, _assign.applyAssign)(schema);
@@ -139,9 +142,6 @@ function attributesToMongoose(attributes) {
   return definition;
 }
 function assertSchemaType(type, path) {
-  if (type === 'Mixed') {
-    throw new Error('Type "Mixed" is not allowed. Use "Object" instead.');
-  }
   if (typeof type === 'string') {
     if (!isMongooseType(type)) {
       const p = path.join('.');

package/dist/cjs/search.js

@@ -13,6 +13,7 @@ var _utils = require("./utils");
 var _const = require("./const");
 var _validation = require("./validation");
 var _env = require("./env");
+var _query = require("./query");
 var _warn = _interopRequireDefault(require("./warn"));
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 const {
@@ -49,29 +50,17 @@ function applySearch(schema, definition) {
       _logger.default.info(`Search query for ${this.modelName}:\n`, JSON.stringify(query, null, 2));
     }
     const mQuery = this.find(query).sort(resolveSort(sort, schema)).skip(skip).limit(limit);
-
-    // The following construct is awkward but it allows the mongoose query
-    // object to be returned while still ultimately resolving with metadata
-    // so that this method can behave like other find methods and importantly
-    // allow custom population with the same API.
-
-    const runQuery = mQuery.then.bind(mQuery);
-    mQuery.then = async (resolve, reject) => {
-      try {
-        const [data, total] = await Promise.all([runQuery(), this.countDocuments(query)]);
-        resolve({
-          data,
-          meta: {
-            total,
-            skip,
-            limit
-          }
-        });
-      } catch (err) {
-        reject(err);
-      }
-    };
-    return mQuery;
+    return (0, _query.wrapQuery)(mQuery, async promise => {
+      const [data, total] = await Promise.all([promise, this.countDocuments(query)]);
+      return {
+        data,
+        meta: {
+          total,
+          skip,
+          limit
+        }
+      };
+    });
   });
 }
 function searchValidation(options = {}) {

package/dist/cjs/serialization.js

@@ -8,7 +8,8 @@ var _lodash = require("lodash");
 var _include = require("./include");
 var _access = require("./access");
 var _utils = require("./utils");
-const serializeOptions = {
+const DISALLOWED_FIELDS = ['deleted', 'deletedRefs'];
+const serializeOptions = exports.serializeOptions = {
   getters: true,
   versionKey: false,
   transform: (doc, ret, options) => {
@@ -17,11 +18,12 @@ const serializeOptions = {
     transformField(ret, doc.schema.obj, options);
   }
 };
-exports.serializeOptions = serializeOptions;
 function transformField(obj, field, options) {
   if (Array.isArray(obj)) {
     for (let el of obj) {
       transformField(el, field, options);
+      // Delete ids in array elements.
+      delete el.id;
     }
   } else if ((0, _lodash.isPlainObject)(obj)) {
     for (let [key, val] of Object.entries(obj)) {
@@ -37,7 +39,7 @@ function isAllowedField(key, field, options) {
   if (key[0] === '_') {
     // Strip internal keys like _id and __v
     return false;
-  } else if (key === 'deleted') {
+  } else if (DISALLOWED_FIELDS.includes(key)) {
     // Strip "deleted" field which defaults
     // to false and should not be exposed.
     return false;