@coderich/autograph 0.10.0 → 0.10.1

package/src/data/Field.js

@@ -1,8 +1,9 @@
+const { isEmpty } = require('lodash');
 const Type = require('./Type');
 const Field = require('../graphql/ast/Field');
-const Rule = require('../core/Rule');
-const Transformer = require('../core/Transformer');
-const { map, uvl, isPlainObject, ensureArray, promiseChain } = require('../service/app.service');
+const Boom = require('../core/Boom');
+const Pipeline = require('./Pipeline');
+const { isPlainObject, ensureArray } = require('../service/app.service');
 
 module.exports = class extends Field {
   constructor(model, field) {
@@ -11,140 +12,89 @@ module.exports = class extends Field {
     this.model = model;
   }
 
-  cast(value) {
-    if (value == null) return value;
-    const casted = Transformer.cast(this.getType())(this, value);
-    return this.isArray() ? ensureArray(casted) : casted;
-  }
-
-  getRules() {
-    const rules = [];
-
-    Object.entries(this.getDirectiveArgs('field', {})).forEach(([key, value]) => {
-      if (!Array.isArray(value)) value = [value];
-      if (key === 'enforce') rules.push(...value.map(r => Rule.getInstances()[r]));
-    });
-
-    if (this.isRequired() && this.isPersistable() && !this.isVirtual()) rules.push(Rule.required());
-
-    return rules.concat(this.type.getRules());
-  }
-
-  getTransformers() {
-    const transformers = [];
-
-    Object.entries(this.getDirectiveArgs('field', {})).forEach(([key, value]) => {
-      if (!Array.isArray(value)) value = [value];
-      if (key === 'transform') transformers.push(...value.map(t => Transformer.getInstances()[t]));
-    });
-
-    return transformers.concat(this.type.getTransformers());
-  }
-
-  getSerializers() {
-    const transformers = [];
-
-    Object.entries(this.getDirectiveArgs('field', {})).forEach(([key, value]) => {
-      if (!Array.isArray(value)) value = [value];
-      if (key === 'serialize') transformers.push(...value.map(t => Transformer.getInstances()[t]));
-    });
-
-    return transformers.concat(this.type.getSerializers());
-  }
-
-  getDeserializers() {
-    const transformers = [];
+  getStructures() {
+    // Grab structures from the underlying type
+    const structures = this.type.getStructures();
+    const { isRequired, isPersistable, isVirtual, isPrimaryKeyId, isIdField } = this.props;
 
-    Object.entries(this.getDirectiveArgs('field', {})).forEach(([key, value]) => {
+    // Structures defined on the field
+    const $structures = Object.entries(this.getDirectiveArgs('field', {})).reduce((prev, [key, value]) => {
       if (!Array.isArray(value)) value = [value];
-      if (key === 'deserialize') transformers.push(...value.map(t => Transformer.getInstances()[t]));
-    });
-
-    return transformers.concat(this.type.getDeserializers());
+      if (key === 'instruct') prev.instructs.unshift(...value.map(t => Pipeline[t]));
+      if (key === 'restruct') prev.restructs.unshift(...value.map(t => Pipeline[t]));
+      if (key === 'destruct') prev.destructs.unshift(...value.map(t => Pipeline[t]));
+      if (key === 'construct') prev.constructs.unshift(...value.map(t => Pipeline[t]));
+      if (key === 'serialize') prev.serializers.unshift(...value.map(t => Pipeline[t]));
+      if (key === 'deserialize') prev.deserializers.unshift(...value.map(t => Pipeline[t]));
+      if (key === 'transform') prev.transformers.unshift(...value.map(t => Pipeline[t]));
+      return prev;
+    }, structures);
+
+    // IDs (first - shift)
+    if (isPrimaryKeyId) $structures.serializers.unshift(Pipeline.idKey);
+    if (isIdField) $structures.$serializers.unshift(Pipeline.idField);
+
+    // Required (last - push)
+    if (isRequired && isPersistable && !isVirtual) $structures.serializers.push(Pipeline.required);
+
+    return $structures;
   }
 
-  getResolvers() {
-    const resolvers = [];
-
-    Object.entries(this.getDirectiveArgs('field', {})).forEach(([key, value]) => {
-      if (!Array.isArray(value)) value = [value];
-      if (key === 'resolve') resolvers.push(...value.map(t => Transformer.getInstances()[t]));
-    });
-
-    return resolvers.concat(this.type.getResolvers());
-  }
+  async validate(query, value) {
+    if (value == null) return value;
+    const { resolver } = query.toObject();
+    const { type, modelRef, isEmbedded } = this.props;
 
-  validate(query, value) {
-    const modelRef = this.getModelRef();
-    const rules = [...this.getRules()];
+    if (modelRef && !isEmbedded) {
+      const ids = Array.from(new Set(ensureArray(value).map(v => `${v}`)));
+      await resolver.match(type).where({ id: ids }).count().then((count) => {
+        // if (type === 'Category') console.log(ids, count);
+        if (count !== ids.length) throw Boom.notFound(`${type} Not Found`);
+      });
+    }
 
-    if (modelRef && !this.isEmbedded()) rules.push(Rule.ensureId());
+    if (modelRef && isPlainObject(ensureArray(value)[0])) return modelRef.validate(query, value); // Model delegation
 
-    return Promise.all(rules.map((rule) => {
-      return rule(this, value, query);
-    })).then((res) => {
-      if (modelRef && isPlainObject(ensureArray(value)[0])) return modelRef.validate(query, value); // Model delegation
-      return res;
-    });
+    return value;
   }
 
-  /**
-   * Ensures the value of the field via bound @value + transformations
-   */
-  transform(query, value, serdes = (() => { throw new Error('No Sir Sir SerDes!'); })()) {
-    // Determine value
-    const $value = serdes === 'serialize' ? this.resolveBoundValue(query, value) : uvl(value, this.getDefaultValue());
+  resolve(resolver, doc, args = {}) {
+    const { name, isArray, isScalar, isVirtual, isRequired, isEmbedded, modelRef, virtualField } = this.props;
+    const value = doc[name];
 
-    // Determine transformers
-    const transformers = [...(serdes === 'serialize' ? this.getSerializers() : this.getDeserializers()), ...this.getTransformers()];
+    // Default resolver return immediately!
+    if (isScalar || isEmbedded) return value;
 
-    // Transform
-    return transformers.reduce((prev, transformer) => {
-      return transformer(this, prev, query);
-    }, this.cast($value));
-  }
+    // Ensure where clause for DB lookup
+    args.where = args.where || {};
 
-  /**
-   * Ensures the value of the field is appropriate for the driver
-   */
-  serialize(query, value, minimal = false) {
-    const modelRef = uvl(this.getModelRef(), this.getType() === 'ID' ? this.model : undefined);
-    const isEmbedded = this.isEmbedded();
+    if (isArray) {
+      if (isVirtual) {
+        if (isEmpty(args.where)) args.batch = `${virtualField}`;
+        args.where[virtualField] = doc.id;
+        return resolver.match(modelRef).merge(args).many();
+      }
 
-    // If embedded, simply delgate
-    if (isEmbedded) return modelRef.serialize(query, value, minimal);
+      // Not a "required" query + strip out nulls
+      if (isEmpty(args.where)) args.batch = 'id';
+      args.where.id = value;
+      return resolver.match(modelRef).merge(args).many();
+    }
 
-    // Now, normalize and resolve
-    const $value = this.transform(query, value, 'serialize');
-    if (modelRef && !isEmbedded) return map($value, v => modelRef.idValue(v.id || v));
-    return $value;
-  }
+    if (isVirtual) {
+      if (isEmpty(args.where)) args.batch = `${virtualField}`;
+      args.where[virtualField] = doc.id;
+      return resolver.match(modelRef).merge(args).one();
+    }
 
-  deserialize(query, value) {
-    return this.transform(query, value, 'deserialize');
+    return resolver.match(modelRef).id(value).one({ required: isRequired });
   }
 
-  /**
-   * Applies any user-defined @field(resolve: [...methods]) in series
-   * This is ONLY run when resolving a value via the $<name> attribute
-   */
-  resolve(query, value) {
-    const resolvers = [...this.getResolvers()];
-
-    return promiseChain(resolvers.map(fn => (chain) => {
-      return Promise.resolve(fn(this, uvl(this.cast(chain.pop()), value), query));
-    })).then((results) => {
-      return uvl(this.cast(results.pop()), value);
-    });
-  }
-
-  tform(query, value) {
-    // Determine transformers
-    const transformers = this.getTransformers();
-
-    // Transform
-    return transformers.reduce((prev, transformer) => {
-      return transformer(this, prev, query);
-    }, this.cast(value));
+  count(resolver, doc, args = {}) {
+    const { name, isVirtual, modelRef, virtualField } = this.props;
+    args.where = args.where || {};
+    if (isVirtual) args.where[virtualField] = doc.id;
+    else args.where.id = doc[name];
+    return resolver.match(modelRef).merge(args).count();
   }
 };

package/src/data/Model.js

@@ -1,6 +1,10 @@
+const Stream = require('stream');
 const Field = require('./Field');
+const Pipeline = require('./Pipeline');
 const Model = require('../graphql/ast/Model');
-const { map, ucFirst, ensureArray } = require('../service/app.service');
+const { paginateResultSet } = require('./DataService');
+const { eventEmitter } = require('../service/event.service');
+const { map, seek, deseek, ensureArray } = require('../service/app.service');
 
 module.exports = class extends Model {
   constructor(schema, model, driver) {
@@ -8,6 +12,7 @@ module.exports = class extends Model {
     this.driver = driver;
     this.fields = super.getFields().map(field => new Field(this, field));
     this.namedQueries = {};
+    this.shapesCache = new Map();
   }
 
   raw() {
@@ -43,133 +48,118 @@ module.exports = class extends Model {
     return this.referentials;
   }
 
+  validate(query, data) {
+    const { flags = {} } = query.toObject();
+    const { validate = true } = flags;
+
+    if (!validate) return Promise.resolve();
+
+    return Promise.all(this.getFields().map((field) => {
+      return Promise.all(ensureArray(map(data, (obj) => {
+        if (obj == null) return Promise.resolve();
+        return field.validate(query, obj[field.getKey()]);
+      })));
+    })).then(() => {
+      return eventEmitter.emit('validate', query);
+    });
+  }
+
   /**
-   * Called when creating a new document. Will add attributes such as id, createdAt, updatedAt
-   * while ensuring that all defaulted values are set appropriately
+   * Convenience method to deserialize data from a data source (such as a database)
    */
-  appendCreateFields(input, embed = false) {
-    // id, createdAt, updatedAt
-    const timestamp = new Date();
-    if (embed && !input.id && this.idKey()) input.id = this.idValue();
-    if (!input.createdAt) input.createdAt = timestamp;
-    input.updatedAt = timestamp;
-
-    // Generate embedded default values
-    this.getEmbeddedFields().filter(field => field.isPersistable()).forEach((field) => {
-      if (input[field]) map(input[field], v => field.getModelRef().appendCreateFields(v, true));
+  deserialize(mixed, query) {
+    const { flags = {} } = query.toObject();
+    const { pipeline = true } = flags;
+    const shape = this.getShape();
+
+    return new Promise((resolve, reject) => {
+      if (!(mixed instanceof Stream)) {
+        resolve(pipeline ? this.shapeObject(shape, mixed, query) : mixed);
+      } else {
+        const results = [];
+        mixed.on('data', (data) => { results.push(pipeline ? this.shapeObject(shape, data, query) : data); });
+        mixed.on('end', () => { resolve(results); });
+        mixed.on('error', reject);
+      }
+    }).then((results) => {
+      return results.length && pipeline ? paginateResultSet(results, query) : results;
     });
-
-    return input;
   }
 
-  appendUpdateFields(input, embed = false) {
-    // id, updatedAt
-    if (embed && !input.id && this.idKey()) input.id = this.idValue();
-    input.updatedAt = new Date();
+  getShape(crud = 'read', target = 'doc', paths = []) {
+    const cacheKey = `${crud}:${target}`;
+    if (this.shapesCache.has(cacheKey)) return this.shapesCache.get(cacheKey);
 
-    // Generate embedded default values
-    this.getEmbeddedFields().filter(field => field.isPersistable()).forEach((field) => {
-      if (input[field]) map(input[field], v => field.getModelRef().appendUpdateFields(v, field.isArray())); // Only embedded when it's an array (because then we'll ensure ids)
-    });
+    const serdes = crud === 'read' ? 'deserialize' : 'serialize';
+    const fields = serdes === 'deserialize' ? this.getSelectFields() : this.getPersistableFields();
+    const crudMap = { create: ['constructs'], update: ['restructs'], delete: ['destructs'], remove: ['destructs'] };
+    const crudKeys = crudMap[crud] || [];
 
-    return input;
-  }
+    const targetMap = {
+      doc: ['defaultValue', 'ensureArrayValue', 'castValue', ...crudKeys, `$${serdes}rs`, 'instructs', 'transformers', `${serdes}rs`],
+      where: ['castValue', `$${serdes}rs`, 'instructs'],
+    };
 
-  appendDefaultFields(query, input) {
-    this.getDefaultedFields().filter(field => field.isPersistable()).forEach((field) => {
-      input[field] = field.resolveBoundValue(query, input[field]);
-    });
+    const structureKeys = targetMap[target] || ['castValue'];
+
+    // Create shape, recursive
+    const shape = fields.map((field) => {
+      const structures = field.getStructures();
+      const [key, name, type, isArray] = [field.getKey(), field.getName(), field.getType(), field.isArray(), field.isIdField()];
+      const [from, to] = serdes === 'serialize' ? [name, key] : [key, name];
+      const path = paths.concat(to);
+      const subShape = field.isEmbedded() ? field.getModelRef().getShape(crud, target, path) : null;
+
+      structures.castValue = Pipeline.castValue;
+      structures.defaultValue = Pipeline.defaultValue;
 
-    // Generate embedded default values
-    this.getEmbeddedFields().filter(field => field.isPersistable()).forEach((field) => {
-      map(input[field], v => field.getModelRef().appendDefaultFields(query, v));
+      structures.ensureArrayValue = ({ value }) => (value != null && isArray && !Array.isArray(value) ? [value] : value);
+      const transformers = structureKeys.reduce((prev, struct) => prev.concat(structures[struct]), []).filter(Boolean);
+      return { field, path, from, to, type, isArray, transformers, shape: subShape };
     });
 
-    return input;
-  }
+    // Adding useful shape info
+    shape.crud = crud;
+    shape.model = this;
+    shape.serdes = serdes;
 
-  /**
-   * Serialize data from Domain Model to Data Model (where clause has special handling)
-   */
-  serialize(query, data, minimal = false) {
-    return this.transform(query, data, 'serialize', minimal);
+    // Cache and return
+    this.shapesCache.set(cacheKey, shape);
+    return shape;
   }
 
-  /**
-   * Deserialize data from Data Model to Domain Model
-   */
-  deserialize(query, data) {
-    return this.transform(query, data, 'deserialize');
-  }
+  shapeObject(shape, obj, query, root) {
+    const { serdes, model } = shape;
+    const { context, doc = {} } = query.toObject();
 
-  /**
-   * Serializer/Deserializer
-   */
-  transform(query, data, serdes = (() => { throw new Error('No Sir Sir SerDes!'); })(), minimal = false) {
-    // Serialize always gets the bound values
-    const appendFields = (serdes === 'serialize' ? [...this.getBoundValueFields()] : []);
-
-    // Certain cases do not want custom serdes or defaults
-    if (!minimal) appendFields.push(...this[`get${ucFirst(serdes)}Fields`](), ...this.getDefaultFields());
-
-    // Transform all the data
-    return map(data, (doc) => {
-      // We want the appendFields + those in the data, deduped
-      const fields = [...new Set(appendFields.concat(Object.keys(doc).map(k => this.getField(k))))].filter(Boolean);
-
-      // Loop through the fields and delegate (renaming keys appropriately)
-      return fields.reduce((prev, field) => {
-        const [key, name] = serdes === 'serialize' ? [field.getKey(), field.getName()] : [field.getName(), field.getKey()];
-        prev[key] = field[serdes](query, doc[name], minimal);
-        return prev;
-      }, {});
-    });
-  }
+    return map(obj, (parent) => {
+      // "root" is the base of the object
+      root = root || parent;
 
-  /**
-   * Normalizes data by renaming keys and serdes on field values (unless keysOnly)
-   */
-  normalize(query, data, serdes = (() => { throw new Error('No Sir Sir SerDes!'); }), keysOnly = false) {
-    // Transform all the data
-    return map(data, (doc) => {
-      const fields = Object.keys(doc).map(k => this.getField(k)).filter(Boolean);
-
-      // Loop through the fields and delegate (renaming keys appropriately)
-      return fields.reduce((prev, field) => {
-        const [key, name] = serdes === 'serialize' ? [field.getKey(), field.getName()] : [field.getName(), field.getKey()];
-        prev[key] = keysOnly ? doc[name] : field[serdes](query, doc[name], true);
-        return prev;
-      }, {});
-    });
-  }
+      // Lookup helper functions
+      const docPath = (p, hint) => seek(doc, p, hint); // doc is already serialized; so always a seek
+      const rootPath = (p, hint) => (serdes === 'serialize' ? seek(root, p, hint) : deseek(shape, root, p, hint));
+      const parentPath = (p, hint) => (serdes === 'serialize' ? seek(parent, p, hint) : deseek(shape, parent, p, hint));
 
-  getShape(serdes = 'deserialize') {
-    return this.getSelectFields().map((field) => {
-      const [from, to] = serdes === 'serialize' ? [field.getName(), field.getKey()] : [field.getKey(), field.getName()];
-      return { from, to, type: field.getDataType(), isArray: field.isArray(), shape: field.isEmbedded() ? field.getModelRef().getShape(serdes) : null };
-    });
-  }
+      return shape.reduce((prev, { field, from, to, path, type, isArray, defaultValue, transformers = [], shape: subShape }) => {
+        const startValue = parent[from];
 
-  shape(data, serdes = (() => { throw new Error('No Sir Sir SerDes!'); }), shape) {
-    shape = shape || this.getShape(serdes);
+        // Transform value
+        const transformedValue = transformers.reduce((value, t) => {
+          const v = t({ model, field, path, docPath, rootPath, parentPath, startValue, value, context });
+          return v === undefined ? value : v;
+        }, startValue);
 
-    return map(data, (doc) => {
-      return shape.reduce((prev, { from, to, shape: subShape }) => {
-        const value = doc[from];
-        if (value === undefined) return prev;
-        return Object.assign(prev, { [to]: subShape ? this.shape(value, serdes, subShape) : value });
-      }, {});
-    });
-  }
+        // if (`${field}` === 'searchability') console.log(startValue, transformedValue, transformers);
 
-  validate(query, data) {
-    const normalized = this.deserialize(query, data);
+        // Determine if key should stay or be removed
+        if (transformedValue === undefined && !Object.prototype.hasOwnProperty.call(parent, from)) return prev;
 
-    return Promise.all(this.getFields().map((field) => {
-      return Promise.all(ensureArray(map(normalized, (obj) => {
-        if (obj == null) return Promise.resolve();
-        return field.validate(query, obj[field.getName()]);
-      })));
-    }));
+        // Rename key & assign value
+        prev[to] = (!subShape || transformedValue == null) ? transformedValue : this.shapeObject(subShape, transformedValue, query, root);
+
+        return prev;
+      }, {});
+    });
   }
 };

package/src/data/Pipeline.js

@@ -0,0 +1,174 @@
+const { uniqWith } = require('lodash');
+const { map, hashObject } = require('../service/app.service');
+const Boom = require('../core/Boom');
+
+module.exports = class Pipeline {
+  constructor() {
+    throw new Error('Pipeline is a singleton; use the static {define|factory} methods');
+  }
+
+  static define(name, factory, options = {}) {
+    // A factory must be a function
+    if (typeof factory !== 'function') throw new Error(`Pipeline definition for "${name}" must be a function`);
+
+    // Determine options; which may come from the factory function
+    const { ignoreNull = true, itemize = true, configurable = false } = Object.assign({}, factory.options, options);
+
+    const wrapper = Object.defineProperty((args) => {
+      if (ignoreNull && args.value == null) return args.value;
+
+      if (ignoreNull && itemize) {
+        return map(args.value, (val, index) => {
+          const v = factory({ ...args, value: val, index });
+          return v === undefined ? val : v;
+        });
+      }
+
+      const val = factory(args);
+      return val === undefined ? args.value : val;
+    }, 'name', { value: name });
+
+    // Attach enumerable method to the Pipeline
+    Object.defineProperty(Pipeline, name, {
+      value: wrapper,
+      configurable,
+      enumerable: true,
+    });
+  }
+
+  static factory(name, thunk, options = {}) {
+    if (typeof thunk !== 'function') throw new Error(`Pipeline factory for "${name}" must be a thunk`);
+    if (typeof thunk() !== 'function') throw new Error(`Factory thunk() for "${name}" must return a function`);
+    Object.defineProperty(Pipeline, name, { value: Object.defineProperty(thunk, 'options', { value: options }) });
+  }
+
+  // static wrapper(name, factory, { ignoreNull, itemize }) {
+  //   return Object.defineProperty((args) => {
+  //     if (ignoreNull && args.value == null) return args.value;
+
+  //     if (ignoreNull && itemize) {
+  //       return map(args.value, (val, index) => {
+  //         const v = factory({ ...args, value: val, index });
+  //         return v === undefined ? val : v;
+  //       });
+  //     }
+
+  //     const val = factory(args);
+  //     return val === undefined ? args.value : val;
+  //   }, 'name', { value: name });
+  // }
+
+  static createPresets() {
+    // Built-In Javascript String Transformers
+    const jsStringTransformers = ['toLowerCase', 'toUpperCase', 'toString', 'trim', 'trimEnd', 'trimStart'];
+    jsStringTransformers.forEach(name => Pipeline.define(`${name}`, ({ value }) => String(value)[name]()));
+
+    // Additional Transformers
+    Pipeline.define('toTitleCase', ({ value }) => value.replace(/\w\S*/g, w => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()));
+    Pipeline.define('toSentenceCase', ({ value }) => value.charAt(0).toUpperCase() + value.slice(1));
+    Pipeline.define('toArray', ({ value }) => (Array.isArray(value) ? value : [value]), { itemize: false });
+    Pipeline.define('toDate', ({ value }) => new Date(value), { configurable: true });
+    Pipeline.define('timestamp', ({ value }) => Date.now(), { ignoreNull: false });
+    Pipeline.define('createdAt', ({ value }) => value || Date.now(), { ignoreNull: false });
+    Pipeline.define('dedupe', ({ value }) => uniqWith(value, (b, c) => hashObject(b) === hashObject(c)), { itemize: false });
+    Pipeline.define('idKey', ({ model, value }) => (value == null ? model.idValue() : value), { ignoreNull: false });
+    Pipeline.define('idField', ({ field, value }) => map(value, v => field.getIdModel().idValue(v.id || v)));
+
+    Pipeline.define('defaultValue', ({ field, value }) => {
+      const { defaultValue } = field.toObject();
+      return value === undefined ? defaultValue : value;
+    }, { ignoreNull: false });
+
+    Pipeline.define('castValue', ({ field, value }) => {
+      const { type, isEmbedded } = field.toObject();
+
+      if (isEmbedded) return value;
+
+      return map(value, (v) => {
+        switch (type) {
+          case 'String': {
+            return `${v}`;
+          }
+          case 'Float': case 'Number': {
+            const num = Number(v);
+            if (!Number.isNaN(num)) return num;
+            return v;
+          }
+          case 'Int': {
+            const num = Number(v);
+            if (!Number.isNaN(num)) return parseInt(v, 10);
+            return v;
+          }
+          case 'Boolean': {
+            if (v === 'true') return true;
+            if (v === 'false') return false;
+            return v;
+          }
+          default: {
+            return v;
+          }
+        }
+      });
+    }, { itemize: false });
+
+    // Required fields
+    Pipeline.define('required', ({ model, field, value }) => {
+      if (value == null) throw Boom.badRequest(`${model}.${field} is required`);
+    }, { ignoreNull: false });
+
+    // A field cannot hold a reference to itself
+    Pipeline.define('selfless', ({ model, field, parentPath, value }) => {
+      if (`${value}` === `${parentPath('id')}`) throw Boom.badRequest(`${model}.${field} cannot hold a reference to itself`);
+    });
+
+    // Once set it cannot be changed
+    Pipeline.define('immutable', ({ model, field, docPath, parentPath, path, value }) => {
+      const hint = { id: parentPath('id') };
+      const oldVal = docPath(path, hint);
+      if (oldVal !== undefined && value !== undefined && `${hashObject(oldVal)}` !== `${hashObject(value)}`) throw Boom.badRequest(`${model}.${field} is immutable; cannot be changed once set ${oldVal} -> ${value}`);
+    });
+
+    // List of allowed values
+    Pipeline.factory('allow', (...args) => function allow({ model, field, value }) {
+      if (args.indexOf(value) === -1) throw Boom.badRequest(`${model}.${field} allows ${args}; found '${value}'`);
+    });
+
+    // List of disallowed values
+    Pipeline.factory('deny', (...args) => function deny({ model, field, value }) {
+      if (args.indexOf(value) > -1) throw Boom.badRequest(`${model}.${field} denys ${args}; found '${value}'`);
+    });
+
+    // Min/Max range
+    Pipeline.factory('range', (min, max) => {
+      if (min == null) min = undefined;
+      if (max == null) max = undefined;
+
+      return function range({ model, field, value }) {
+        const num = +value; // Coerce to number if possible
+        const test = Number.isNaN(num) ? value.length : num;
+        if (test < min || test > max) throw Boom.badRequest(`${model}.${field} must satisfy range ${min}:${max}; found '${value}'`);
+      };
+    }, { itemize: false });
+  }
+};
+
+
+// const jsStringMethods = [
+//   'charAt', 'charCodeAt', 'codePointAt', 'concat', 'indexOf', 'lastIndexOf', 'localeCompare',
+//   'normalize', 'padEnd', 'padStart', 'repeat', 'replace', 'search', 'slice', 'split', 'substr', 'substring',
+//   'toLocaleLowerCase', 'toLocaleUpperCase', 'toLowerCase', 'toString', 'toUpperCase', 'trim', 'trimEnd', 'trimStart', 'raw',
+// ];
+
+// Transformer.factory('toTitleCase', () => ({ value }) => value.replace(/\w\S*/g, w => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()), { enumerable: true });
+// Transformer.factory('toLocaleTitleCase', (...args) => ({ value }) => value.replace(/\w\S*/g, w => w.charAt(0).toLocaleUpperCase(...args) + w.slice(1).toLocaleLowerCase()));
+// Transformer.factory('toSentenceCase', () => ({ value }) => value.charAt(0).toUpperCase() + value.slice(1), { enumerable: true });
+// Transformer.factory('toLocaleSentenceCase', (...args) => ({ value }) => value.charAt(0).toLocaleUpperCase(...args) + value.slice(1));
+// Transformer.factory('toArray', () => ({ value }) => (Array.isArray(value) ? value : [value]), { itemize: false, enumerable: true });
+// Transformer.factory('toDate', () => ({ value }) => new Date(value), { enumerable: true, writable: true });
+// Transformer.factory('dedupe', () => ({ value }) => uniqWith(value, (b, c) => hashObject(b) === hashObject(c)), { ignoreNull: false, enumerable: true });
+// Transformer.factory('dedupeBy', key => ({ value }) => uniqWith(value, (b, c) => hashObject(b[key]) === hashObject(c[key])), { ignoreNull: false, enumerable: true });
+// Transformer.factory('timestamp', () => () => Date.now(), { enumerable: true, ignoreNull: false });
+// Transformer.factory('createdAt', () => ({ value }) => value || Date.now(), { enumerable: true, ignoreNull: false });
+// Transformer.factory('first', () => ({ value }) => (Array.isArray(value) ? value[0] : value), { enumerable: true });
+// Transformer.factory('get', path => ({ value }) => get(value, path), { enumerable: true });
+// Transformer.factory('set', path => ({ value }) => set({}, path, value), { enumerable: true });