@coderich/autograph 0.10.0 → 0.10.1

package/src/query/QueryResolver.js

@@ -1,77 +1,110 @@
-const { get, isEmpty } = require('lodash');
+const { get, set, isEmpty } = require('lodash');
 const Boom = require('../core/Boom');
 const QueryService = require('./QueryService');
 const DataService = require('../data/DataService');
 const { createSystemEvent } = require('../service/event.service');
-const { mergeDeep } = require('../service/app.service');
+const { mergeDeep, getGQLReturnType } = require('../service/app.service');
 
 module.exports = class QueryResolver {
   constructor(query) {
     this.query = query;
     this.resolver = query.toObject().resolver;
+    this.context = this.resolver.getContext();
   }
 
-  findOne(query) {
-    return createSystemEvent('Query', { method: 'get', query }, () => {
+  autoResolve(query) {
+    const { args } = query.toObject();
+    const [,,, info] = args;
+
+    switch (getGQLReturnType(info.returnType)) {
+      case 'array': {
+        return new QueryResolver(this.query.clone().method('findMany')).resolve();
+      }
+      case 'number': {
+        return new QueryResolver(this.query.clone().method('count')).resolve();
+      }
+      case 'connection': {
+        return Promise.resolve({
+          count: () => new QueryResolver(this.query.clone().method('count')).resolve(),
+          edges: () => new QueryResolver(this.query.clone().method('findMany')).resolve(),
+          pageInfo: () => new QueryResolver(this.query.clone().method('findMany')).resolve(),
+        });
+      }
+      case 'scalar': default: {
+        return new QueryResolver(this.query.clone().method('findOne')).resolve();
+      }
+    }
+  }
+
+  async findOne(query) {
+    await QueryService.resolveQuery(query);
+
+    return createSystemEvent('Query', { query }, () => {
       return this.resolver.resolve(query);
     });
   }
 
-  findMany(query) {
-    return createSystemEvent('Query', { method: 'find', query }, () => {
+  async findMany(query) {
+    await QueryService.resolveQuery(query);
+
+    return createSystemEvent('Query', { query }, () => {
       return this.resolver.resolve(query);
     });
   }
 
-  count(query) {
-    return createSystemEvent('Query', { method: 'count', query }, () => {
+  async count(query) {
+    await QueryService.resolveQuery(query);
+
+    return createSystemEvent('Query', { query }, () => {
       return this.resolver.resolve(query);
     });
   }
 
-  createOne(query) {
-    const { model, input, flags } = query.toObject();
-    model.appendDefaultFields(query, input);
+  async createOne(query) {
+    const { model, input } = query.toObject();
+    const shape = model.getShape('create');
 
-    return createSystemEvent('Mutation', { method: 'create', query }, async () => {
-      const $input = model.serialize(query, model.appendCreateFields(input));
-      query.$input($input);
-      if (!get(flags, 'novalidate')) await model.validate(query, $input);
-      const doc = await this.resolver.resolve(query);
+    await QueryService.resolveQuery(query);
+
+    return createSystemEvent('Mutation', { query }, async () => {
+      const $input = model.shapeObject(shape, input, query);
+      await model.validate(query, $input);
+      const doc = await this.resolver.resolve(query.$input($input));
       query.doc(doc);
       return doc;
     });
   }
 
   createMany(query) {
-    const { model, args, transaction } = query.toObject();
+    const { model, input, transaction } = query.toObject();
     const txn = this.resolver.transaction(transaction);
-    args.forEach(arg => txn.match(model).save(arg));
+    input.forEach(arg => txn.match(model).save(arg));
     return txn.run();
   }
 
-  updateOne(query) {
-    const { model, match, flags } = query.toObject();
+  async updateOne(query) {
+    const { model, match, input } = query.toObject();
+
+    return this.resolver.match(model).match(match).one({ required: true }).then(async (doc) => {
+      const shape = model.getShape('update');
+      const merged = model.shapeObject(shape, mergeDeep(doc, input), query);
 
-    return this.resolver.match(model).match(match).one({ required: true }).then((doc) => {
-      const { input } = query.toObject();
-      const merged = mergeDeep(doc, input);
+      await QueryService.resolveQuery(query);
 
-      return createSystemEvent('Mutation', { method: 'update', query: query.doc(doc).merged(merged) }, async () => {
-        const $input = model.serialize(query, model.appendUpdateFields(input), true);
-        if (!get(flags, 'novalidate')) await model.validate(query, $input);
-        const $doc = mergeDeep(model.serialize(query, doc, true), $input);
-        return this.resolver.resolve(query.$doc($doc).$input($input));
+      return createSystemEvent('Mutation', { query: query.doc(doc).merged(merged) }, async () => {
+        const $doc = model.shapeObject(shape, mergeDeep(doc, input), query);
+        await model.validate(query, $doc);
+        return this.resolver.resolve(query.$doc($doc));
       });
     });
   }
 
   updateMany(query) {
-    const { model, args, match, transaction, flags } = query.toObject();
+    const { model, input, match, transaction, flags } = query.toObject();
 
-    return this.resolver.match(model).match(match).flags(flags).many().then((docs) => {
+    return this.resolver.match(model).match(match).many(flags).then((docs) => {
       const txn = this.resolver.transaction(transaction);
-      docs.forEach(doc => txn.match(model).id(doc.id).save(...args));
+      docs.forEach(doc => txn.match(model).id(doc.id).save(input, flags));
       return txn.run();
     });
   }
@@ -79,8 +112,10 @@ module.exports = class QueryResolver {
   deleteOne(query) {
     const { model, id, flags } = query.toObject();
 
-    return this.resolver.match(model).id(id).flags(flags).one({ required: true }).then((doc) => {
-      return createSystemEvent('Mutation', { method: 'delete', query: query.doc(doc) }, () => {
+    return this.resolver.match(model).id(id).flags(flags).one({ required: true }).then(async (doc) => {
+      await QueryService.resolveQuery(query);
+
+      return createSystemEvent('Mutation', { query: query.doc(doc) }, () => {
         return QueryService.resolveReferentialIntegrity(query).then(() => {
           return this.resolver.resolve(query).then(() => doc);
         });
@@ -151,16 +186,28 @@ module.exports = class QueryResolver {
   }
 
   splice(query) {
-    const { model, match, args, flags } = query.toObject();
+    const { model, match, args, flags = {} } = query.toObject();
     const [key, from, to] = args;
 
-    return this.resolver.match(model).match(match).flags(flags).one({ required: true }).then(async (doc) => {
-      await DataService.spliceEmbeddedArray(query, doc, key, from, to);
+    // Can only splice arrays
+    const field = model.getField(key);
+    const isArray = field.isArray();
+    if (!isArray) throw Boom.badRequest(`Cannot splice field '${model}.${field}'`);
 
-      return createSystemEvent('Mutation', { method: 'update', query: query.doc(doc).merged(doc) }, async () => {
-        await model.validate(query, doc);
-        const $doc = model.serialize(query, doc, true);
-        return this.resolver.resolve(query.method('updateOne').doc(doc).$doc($doc));
+    return this.resolver.match(model).match(match).flags(flags).one({ required: true }).then(async (doc) => {
+      const array = get(doc, key) || [];
+      const paramShape = model.getShape('create', 'spliceTo');
+      const $to = model.shapeObject(paramShape, { [key]: to }, query)[key] || to;
+      const $from = model.shapeObject(paramShape, { [key]: from }, query)[key] || from;
+      set(doc, key, DataService.spliceEmbeddedArray(array, $from, $to));
+
+      await QueryService.resolveQuery(query);
+
+      return createSystemEvent('Mutation', { query: query.method('updateOne').doc(doc).merged(doc) }, async () => {
+        const shape = model.getShape('update');
+        const $doc = model.shapeObject(shape, doc, query);
+        await model.validate(query, $doc);
+        return this.resolver.resolve(query.$doc($doc));
       });
     });
   }
@@ -173,11 +220,14 @@ module.exports = class QueryResolver {
     return this.findMany(query.method('findMany'));
   }
 
-  resolve() {
+  async resolve() {
     const { model, method, flags } = this.query.toObject();
 
+    // const resolveQueryMethods = ['findOne', 'findMany', 'count', 'createOne', 'updateOne', 'deleteOne', 'splice'];
+    // if (resolveQueryMethods.indexOf(method) > -1) await QueryService.resolveQuery(this.query);
+
     return this[method](this.query).then((data) => {
-      if (flags.required && (data == null || isEmpty(data))) throw Boom.notFound(`${model} Not Found`);
+      if (flags.required && isEmpty(data)) throw Boom.notFound(`${model} Not Found`);
       if (data == null) return null; // Explicitly return null here
       return data;
     });

package/src/query/QueryService.js

@@ -1,50 +1,31 @@
 const { get, set, uniq, flattenDeep } = require('lodash');
-const { map, keyPaths, ensureArray, isPlainObject } = require('../service/app.service');
-
-const resolveEmbeddedWhere = (ref, key, value) => {
-  const resolved = ensureArray(map(value, (obj) => {
-    return Object.entries(obj).reduce((p, [k, v]) => {
-      const f = ref.getFieldByName(k);
-
-      if (k === 'id') return Object.assign(p, { [k]: ref.idValue(v) });
-      if (f.isScalar()) return Object.assign(p, { [k]: v });
-      if (f.isEmbedded()) return Object.assign(p, { [k]: resolveEmbeddedWhere(f.getModelRef(), k, v) });
-      return Object.assign(p, { [k]: v });
-    }, {});
-  }));
-
-  return resolved.length > 1 ? resolved : resolved[0];
-};
+const { keyPaths, ensureArray, isPlainObject } = require('../service/app.service');
 
+/**
+ * The where clause may contain attributes that are NOT in the model
+ * This can happen because the where clause reaches into the schema via refs/virtual refs
+ */
 exports.resolveWhereClause = (query) => {
   const { resolver, model, match: where = {}, flags = {} } = query.toObject();
+  const shape = model.getShape('create', 'where');
 
-  // This is needed for where clause (but why!?!)
-  if (where.id) where.id = map(where.id, v => model.idValue(v));
+  const $where = Object.entries(where).reduce((prev, [from, value]) => {
+    const el = shape.find(s => s.from === from);
+    if (!el) return prev; // There's no knowing what this could be
 
-  // Construct
-  const $where = Object.entries(where).reduce((prev, [key, value]) => {
-    const field = model.getField(key);
-    if (!field) return prev;
-    const modelRef = field.getModelRef();
+    const { isVirtual, isEmbedded, modelRef, virtualRef } = el.field.toObject();
 
-    if (field.isVirtual()) {
-      const virtualRef = field.getVirtualRef();
+    if (isVirtual) {
       const ids = Promise.all(ensureArray(value).map(v => resolver.match(modelRef).where(isPlainObject(v) ? v : { id: v }).many(flags).then(docs => docs.map(doc => doc[virtualRef])))).then(results => uniq(flattenDeep(results)));
       return Object.assign(prev, { id: ids });
     }
 
-    if (modelRef && !field.isEmbedded()) {
+    if (modelRef && !isEmbedded) {
       const ids = Promise.all(ensureArray(value).map(v => (isPlainObject(v) ? resolver.match(modelRef).where(v).many(flags).then(docs => docs.map(doc => doc.id)) : Promise.resolve(v)))).then(results => uniq(flattenDeep(results)));
-      return Object.assign(prev, { [key]: ids });
+      return Object.assign(prev, { [from]: ids });
     }
 
-    // You do not have a unit-test that tests this (BUT ITS NEEDED)
-    if (field.isEmbedded()) {
-      return Object.assign(prev, { [key]: resolveEmbeddedWhere(modelRef, key, value) });
-    }
-
-    return Object.assign(prev, { [key]: value });
+    return Object.assign(prev, { [from]: value });
   }, {});
 
   // Resolve
@@ -61,7 +42,8 @@ exports.resolveWhereClause = (query) => {
 
 exports.resolveSortBy = (query) => {
   const { model, sort = {} } = query.toObject();
-  const $sort = model.normalize(query, sort, 'serialize', true);
+  const shape = model.getShape('create', 'sortBy');
+  const $sort = model.shapeObject(shape, sort, query);
 
   // Because normalize casts the value (sometimes to an array) need special handling
   keyPaths($sort).forEach((path) => {
@@ -127,3 +109,18 @@ exports.resolveReferentialIntegrity = (query) => {
     }
   });
 };
+
+exports.resolveQuery = async (query) => {
+  const { model, sort, native, batch, match } = query.toObject();
+
+  if (!native) {
+    const shape = model.getShape('create', 'where');
+    const $where = batch ? match : await exports.resolveWhereClause(query);
+    const $$where = model.shapeObject(shape, $where, query);
+    query.match($$where);
+  }
+
+  if (sort) {
+    query.$sort(exports.resolveSortBy(query));
+  }
+};

package/src/service/app.service.js

@@ -54,6 +54,11 @@ exports.stripObjectUndefineds = obj => Object.entries(obj).reduce((prev, [key, v
 exports.pushIt = (arr, it) => arr[arr.push(it) - 1];
 exports.toKeyObj = obj => exports.keyPaths(obj).reduce((prev, path) => Object.assign(prev, { [path]: _.get(obj, path) }), {});
 
+exports.getGQLReturnType = (returnType) => {
+  const typeMap = { array: /^\[.+\].?$/, connection: /.+Connection!?$/, number: /^(Int|Float)!?$/, scalar: /.*/ };
+  return Object.entries(typeMap).find(([type, pattern]) => returnType.match(pattern))[0];
+};
+
 exports.removeUndefinedDeep = (obj) => {
   return exports.unravelObject(exports.keyPaths(obj).reduce((prev, path) => {
     const value = _.get(obj, path);
@@ -90,7 +95,8 @@ exports.map = (mixed, fn) => {
   if (mixed == null) return mixed;
   const isArray = Array.isArray(mixed);
   const arr = isArray ? mixed : [mixed];
-  const results = arr.map(el => fn(el));
+  // const results = arr.map((...args) => fn(...args));
+  const results = arr.map((el, i, a) => fn(el, isArray ? i : undefined, isArray ? a : undefined));
   return isArray ? results : results[0];
 };
 
@@ -141,14 +147,6 @@ exports.objectContaining = (a, b) => {
   return exports.hashObject(a) === exports.hashObject(b);
 };
 
-exports.serialize = (field, value) => {
-  if (!exports.isPlainObject(value)) return value;
-  const model = field.getModelRef();
-  if (!model) return value;
-  const key = model.idKey();
-  return value[key];
-};
-
 /**
  * Transform an object with dot.notation keys into an expanded object.
  * eg. { 'user.name': 'richard' } => { user: { name: 'richard' } }
@@ -266,3 +264,63 @@ exports.proxyDeep = (obj, handler, proxyMap = new WeakMap(), path = '') => {
 
   return finalProxy;
 };
+
+exports.resolveDataObject = (obj) => {
+  return Promise.all(Object.keys(obj).map(async (key) => {
+    const value = await obj[key];
+    return { key, value };
+  })).then((results) => {
+    return results.reduce((prev, { key, value }) => {
+      return Object.assign(prev, { [key]: value });
+    }, {});
+  });
+};
+
+exports.seek = (obj, paths, hint) => {
+  // We first do a normal get
+  const value = _.get(obj, paths);
+  if (!hint || value !== undefined) return value;
+
+  // Normalize paths & hint for traversal
+  const $paths = Array.isArray(paths) ? paths : paths.split('.');
+  const $hint = exports.unravelObject(hint);
+
+  // Traverse paths and get as close to the value as possible
+  const { currentValue, pathsToGo } = $paths.reduce((prev, path, i, arr) => {
+    if (prev.currentValue === undefined) return prev;
+    if (!Object.prototype.hasOwnProperty.call(prev.currentValue, path)) return prev;
+    prev.currentValue = prev.currentValue[path];
+    prev.pathsToGo = arr.slice(i + 1);
+    return prev;
+  }, { currentValue: obj, pathsToGo: $paths });
+
+  // Only if we hit an array can we continue
+  if (!Array.isArray(currentValue)) return undefined;
+
+  // If we got to the last segment we need the hint in order to verify
+  const lastPath = Boolean(pathsToGo.length === 1);
+  const arr = lastPath ? currentValue.filter(v => exports.objectContaining(v, $hint)) : currentValue;
+
+  // We keep going, recursive, till we find the first value
+  return arr.reduce((prev, v) => prev || exports.seek(v, pathsToGo, $hint), undefined);
+};
+
+exports.deseek = (shape, obj, paths, hint) => {
+  // Normalize paths
+  const $paths = (Array.isArray(paths) ? paths : paths.split('.')).map((path) => {
+    const item = shape.find(s => s.to === path); // Deserializing from unknown to expected
+    return item ? item.from : path;
+  });
+
+  // Normalize hint
+  const $hint = Object.entries(exports.toKeyObj(hint)).reduce((prev, [key, value]) => {
+    const segments = key.split('.').map((path) => {
+      const item = shape.find(s => s.to === path); // Deserializing from unknown to expected
+      return item ? item.from : path;
+    });
+
+    return Object.assign(prev, { [segments.join('.')]: value });
+  }, {});
+
+  return exports.seek(obj, $paths, $hint);
+};

package/src/service/event.service.js

@@ -1,59 +1,26 @@
-const QueryService = require('../query/QueryService');
 const EventEmitter = require('../core/EventEmitter');
-const { ensureArray, ucFirst } = require('./app.service');
+const { ucFirst } = require('./app.service');
 
 // Event emitters
 const eventEmitter = new EventEmitter().setMaxListeners(100);
-const internalEmitter = new EventEmitter().setMaxListeners(100);
 const systemEvent = new EventEmitter().setMaxListeners(100).on('system', async (event, next) => {
   const { type, data } = event;
-  await internalEmitter.emit(type, data);
   next(await eventEmitter.emit(type, data)); // Return result from user-defined middleware
 });
 
 //
 exports.createSystemEvent = (name, mixed = {}, thunk = () => {}) => {
   let event = mixed;
-  let middleware = () => Promise.resolve();
   const type = ucFirst(name);
 
   if (name !== 'Setup' && name !== 'Response') {
-    const { method, query } = mixed;
-    const { resolver, model, meta, doc, id, input, sort, merged, native, root, crud } = query.toObject();
-
-    event = {
-      context: resolver.getContext(),
-      key: `${method}${model}`,
-      resolver,
-      method,
-      crud,
-      model,
-      meta,
-      id,
-      input,
-      query,
-      doc,
-      merged,
-      root,
-    };
-
-    middleware = () => new Promise(async (resolve) => {
-      if (!native) {
-        const $where = await QueryService.resolveWhereClause(query);
-        query.match(model.serialize(query, $where, true));
-      }
-
-      if (sort) {
-        query.$sort(QueryService.resolveSortBy(query));
-      }
-
-      resolve();
-    });
+    const { query } = mixed;
+    event = query.toObject();
+    event.query = query;
   }
 
   return systemEvent.emit('system', { type: `pre${type}`, data: event }).then((result) => {
-    if (result !== undefined) return result; // Allowing middleware to dictate result
-    return middleware().then(thunk);
+    return (result !== undefined) ? result : thunk(); // Allowing middleware to dictate result
   }).then((result) => {
     event.result = result;
     if (event.crud === 'create') event.doc = event.query.toObject().doc;
@@ -66,44 +33,3 @@ exports.createSystemEvent = (name, mixed = {}, thunk = () => {}) => {
 };
 
 exports.eventEmitter = eventEmitter;
-exports.internalEmitter = internalEmitter;
-
-
-/**
- * Hook into the pre event only!
- *
- * Kick off system events for embedded fields
- */
-const eventHandler = (event) => {
-  const { model, input, method, doc = input, query } = event;
-
-  return Promise.all(model.getEmbeddedFields().map((field) => {
-    return new Promise((resolve, reject) => {
-      if (Object.prototype.hasOwnProperty.call(input || {}, field.getName())) {
-        let i = 0;
-        const value = input[field.getName()];
-        const values = ensureArray(value).filter(el => el != null);
-        const newModel = field.getModelRef();
-
-        if (values.length) {
-          values.forEach((val) => {
-            const clone = query.clone().model(newModel).input(val).doc(doc);
-            exports.createSystemEvent('Mutation', { method, query: clone }, () => {
-              if (++i >= values.length) resolve();
-            }).catch(e => reject(e));
-            // const newEvent = { parent: doc, key: `${method}${field}`, method, model: newModel, resolver, query: new Query(resolver, newModel, { meta }), input: val };
-            // exports.createSystemEvent('Mutation', newEvent, () => {
-            //   if (++i >= values.length) resolve();
-            // }).catch(e => reject(e));
-          });
-        } else {
-          resolve();
-        }
-      } else {
-        resolve();
-      }
-    });
-  }));
-};
-
-internalEmitter.on('preMutation', async (event, next) => eventHandler(event).then(next)); // Only preMutation!

package/src/service/schema.service.js

@@ -54,11 +54,13 @@ exports.getSchemaData = (schema) => {
 exports.identifyOnDeletes = (models, parentModel) => {
   return models.reduce((prev, model) => {
     model.getOnDeleteFields().forEach((field) => {
-      if (`${field.getModelRef()}` === `${parentModel}`) {
+      const { modelRef, isArray } = field.toObject();
+
+      if (`${modelRef}` === `${parentModel}`) {
         if (model.isEntity()) {
-          prev.push({ model, field, isArray: field.isArray(), op: field.getOnDelete() });
+          prev.push({ model, field, isArray, op: field.getOnDelete() });
         } else {
-          prev.push(...exports.identifyOnDeletes(models, model).map(od => Object.assign(od, { fieldRef: field, isArray: field.isArray(), op: field.getOnDelete() })));
+          prev.push(...exports.identifyOnDeletes(models, model).map(od => Object.assign(od, { fieldRef: field, isArray, op: field.getOnDelete() })));
         }
       }
     });

package/src/core/Rule.js

@@ -1,107 +0,0 @@
-const { get } = require('lodash');
-const isEmail = require('validator/lib/isEmail');
-const Boom = require('./Boom');
-const { map, ensureArray, hashObject } = require('../service/app.service');
-
-const instances = {};
-const jsStringMethods = ['endsWith', 'includes', 'match', 'search', 'startsWith'];
-
-class Rule {
-  constructor(thunk, options = {}, name = 'Unknown') {
-    const {
-      ignoreNull = true,
-      itemize = true,
-      toError = (field, value, msg) => Boom.notAcceptable(`Rule (${name}) failed for { ${field.getModel()}.${field}: ${value} }`),
-    } = (options || {});
-
-    return Object.defineProperty((field, val, query) => {
-      return new Promise((resolve, reject) => {
-        if (ignoreNull && val == null) return resolve();
-
-        if (ignoreNull && itemize) {
-          return Promise.all(ensureArray(map(val, async (v) => {
-            const err = await thunk(field, v, query);
-            if (err) return Promise.reject(toError(field, v));
-            return Promise.resolve();
-          }))).then(v => resolve()).catch(e => reject(e));
-        }
-
-        return Promise.all([(async () => {
-          const err = await thunk(field, val, query);
-          if (err) return Promise.reject(toError(field, val));
-          return Promise.resolve();
-        })()]).then(v => resolve()).catch(e => reject(e));
-      });
-    }, 'type', { value: 'rule' });
-  }
-
-  static factory(name, thunk, options = {}) {
-    return Object.defineProperty(Rule, name, {
-      value: (...args) => Object.defineProperty(new Rule(thunk(...args), options, name), 'method', { value: name }),
-      writable: options.writable,
-      enumerable: options.enumerable,
-    })[name];
-  }
-
-  static extend(name, instance) {
-    const invalidArg = () => { throw new Error('Invalid argument; expected Rule factory instance'); };
-    const { method = invalidArg(), type = invalidArg() } = instance;
-    if (type !== 'rule' || !Rule[method]) invalidArg();
-    return (instances[name] = instance);
-  }
-
-  static getInstances() {
-    const defaultRules = Object.entries(Rule).map(([name, method]) => ({ name, instance: method() }));
-    const customRules = Object.entries(instances).map(([name, instance]) => ({ name, instance }));
-    const rules = defaultRules.concat(customRules);
-    return rules.reduce((prev, { name, instance }) => Object.assign(prev, { [name]: instance }), {});
-  }
-}
-
-// Factory methods
-jsStringMethods.forEach(name => Rule.factory(name, (...args) => (f, v) => !String(v)[name](...args)));
-
-// Ensures Foreign Key relationships
-Rule.factory('ensureId', () => (f, v, q) => {
-  const { resolver } = q.toObject();
-  return resolver.match(f.getType()).id(v).one().then(doc => Boolean(doc == null));
-});
-
-// Enforces required fields (only during create)
-Rule.factory('required', () => (f, v, q) => {
-  const { crud, input } = q.toObject();
-  return (crud === 'create' ? v == null : Object.prototype.hasOwnProperty.call(input, f.getName()) && v == null);
-}, { ignoreNull: false, enumerable: true });
-
-// A field cannot hold a reference to itself (model)
-Rule.factory('selfless', () => (f, v, q) => {
-  const { doc } = q.toObject();
-  if (`${v}` === `${get(doc, 'id')}`) throw Boom.badRequest(`${f.getModel()}.${f.getName()} cannot hold a reference to itself`);
-  return false;
-}, { enumerable: true });
-
-// Once set it cannot be changed
-Rule.factory('immutable', () => (f, v, q) => {
-  const { doc, crud } = q.toObject();
-  const path = `${f.getModel()}.${f.getName()}`;
-  const p = path.substr(path.indexOf('.') + 1);
-  const oldVal = get(doc, p);
-  if (crud === 'update' && oldVal !== undefined && v !== undefined && `${hashObject(v)}` !== `${hashObject(oldVal)}`) throw Boom.badRequest(`${path} is immutable; cannot be changed once set`);
-  return false;
-}, { enumerable: true });
-
-Rule.factory('allow', (...args) => (f, v) => args.indexOf(v) === -1);
-Rule.factory('deny', (...args) => (f, v) => args.indexOf(v) > -1);
-Rule.factory('range', (min, max) => {
-  if (min == null) min = undefined;
-  if (max == null) max = undefined;
-  return (f, v) => {
-    const num = +v; // Coerce to number if possible
-    const test = Number.isNaN(num) ? v.length : num;
-    return test < min || test > max;
-  };
-}, { itemize: false });
-Rule.factory('email', () => (f, v) => !isEmail(v), { enumerable: true });
-Rule.factory('distinct', () => (f, v) => false, { enumerable: true });
-
-module.exports = Rule;