@coderich/autograph 0.10.1 → 0.10.4

package/CHANGELOG.md

@@ -2,26 +2,25 @@
 
 ## v0.10.x
 - Replaced ResultSet -> POJOs
-  - Removed all $$ magic resolver methods
-  - Removed all $ magic field methods
+  - Removed all $field methods (auto populated)
   - Removed .toObject()
+  - $model $save remove $delete $lookup $cursor $pageInfo
 - Removed embedded API completely
 - Removed Directives
   - embedApi -> no replacement
   - enforce -> use pipeline methods
   - resolve -> use graphql resolvers
   - @value -> use @field.instruct directive
-- Removed toId Transform -> use @field(id: '')
 - Removed Model.tform() -> use Model.shapeObject(shape, data)
-- Removed Resolver.toResultSet() -> ? TBD ?
 - Removed Transformer + Rule -> use Pipeline
   - Removed many pre-defined rules + transformers
-  - Pre-defined names start with $ (eg. $toLowerCase)
   - Moved "validator" to dev dependency -> isEmail
 - Added QueryBuilder.resolve() terminal command
 - Exported SchemaDecorator -> Schema
 - Removed embedded schema SystemEvents (internal emitter also removed)
 - Removed spread of arguments in QueryBuilder terminal commands (must pass in array)
+- Mutate "merged" instead of "input"
+- Validate "payload"
 
 ## v0.9.x
 - Subscriptions API

package/index.js

@@ -1,5 +1,4 @@
 const Schema = require('./src/core/Schema');
-const GraphQL = require('./src/core/GraphQL');
 const Resolver = require('./src/core/Resolver');
 const Pipeline = require('./src/data/Pipeline');
 const Driver = require('./src/driver');
@@ -7,7 +6,6 @@ const { eventEmitter: Emitter } = require('./src/service/event.service');
 
 module.exports = {
   Schema,
-  GraphQL,
   Resolver,
   Driver,
   Emitter,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@coderich/autograph",
   "author": "Richard Livolsi (coderich)",
-  "version": "0.10.1",
+  "version": "0.10.4",
   "description": "AutoGraph",
   "keywords": [
     "graphql",
@@ -23,16 +23,14 @@
   },
   "scripts": {
     "start": "APP_ROOT_PATH=$(pwd) node ./test/server",
-    "test": "APP_ROOT_PATH=$(pwd) ratchet test --forceExit",
+    "test": "APP_ROOT_PATH=$(pwd) ratchet test",
     "test:debug": "APP_ROOT_PATH=$(pwd) node --inspect-brk ./node_modules/jest/bin/jest.js --watch --runInBand --logHeapUsage",
     "lint": "APP_ROOT_PATH=$(pwd) ratchet lint",
     "inspect": "APP_ROOT_PATH=$(pwd) node --expose-gc --inspect=9222 ./src/server",
     "ratchet": "ratchet"
   },
   "dependencies": {
-    "@graphql-tools/schema": "^8.3.14",
     "@hapi/boom": "^9.1.0",
-    "axios": "^0.21.4",
     "dataloader": "^2.0.0",
     "deepmerge": "^4.2.2",
     "fill-range": "^7.0.1",
@@ -41,11 +39,11 @@
     "lodash": "^4.17.21",
     "mongodb": "^4.8.0",
     "object-hash": "^2.0.1",
-    "picomatch": "^2.1.1",
-    "uuid": "^3.3.3"
+    "picomatch": "^2.1.1"
   },
   "devDependencies": {
     "@coderich/ratchet": "^1.5.7",
+    "@graphql-tools/schema": "^9.0.1",
     "graphql": "^15.5.0",
     "mongodb-memory-server": "^8.7.2",
     "neo4j-driver": "^4.0.0",

package/src/core/Resolver.js

@@ -1,7 +1,10 @@
 const Model = require('../data/Model');
 const DataLoader = require('../data/DataLoader');
 const DataTransaction = require('../data/DataTransaction');
+const Query = require('../query/Query');
 const QueryBuilder = require('../query/QueryBuilder');
+const { finalizeResults } = require('../data/DataService');
+const { createSystemEvent } = require('../service/event.service');
 
 module.exports = class Resolver {
   constructor(schema, context = {}) {
@@ -58,7 +61,8 @@ module.exports = class Resolver {
       case 'create': case 'update': case 'delete': {
         return model.getDriver().resolve(query.toDriver()).then((data) => {
           this.clear(model);
-          return model.shapeObject(model.getShape(), data, query);
+          const rs = model.shapeObject(model.getShape(), data, query);
+          return finalizeResults(rs, query);
         });
       }
       default: {
@@ -99,25 +103,13 @@ module.exports = class Resolver {
     return entity;
   }
 
-  // toResultSet(model, data, method) {
-  //   const crud = ['get', 'find', 'count'].indexOf(method) > -1 ? 'read' : method;
-  //   const doc = model.shape(data);
-  //   const result = doc;
-  //   const merged = doc;
-
-  //   return createSystemEvent('Response', {
-  //     model,
-  //     crud,
-  //     method,
-  //     result,
-  //     doc,
-  //     merged,
-  //     resolver: this,
-  //     key: `${method}${model}`,
-  //     context: this.getContext(),
-  //     query: query.doc(result).merged(result),
-  //   }, () => result);
-  // }
+  toResultSet(model, data, method) {
+    model = this.toModel(model);
+    const query = new Query({ model, resolver: this, context: this.context, method });
+    const result = model.deserialize(data, query);
+    const event = { result, query, ...query.doc(result).merged(result).toObject() };
+    return createSystemEvent('Response', event, () => result);
+  }
 
   // DataLoader Proxy Methods
   clear(model) {

package/src/core/Schema.js

@@ -1,7 +1,7 @@
 const Model = require('../data/Model');
 const Schema = require('../graphql/ast/Schema');
 const { identifyOnDeletes } = require('../service/schema.service');
-const { createSystemEvent } = require('../service/event.service');
+const { eventEmitter } = require('../service/event.service');
 
 // Export class
 module.exports = class extends Schema {
@@ -23,7 +23,7 @@ module.exports = class extends Schema {
   }
 
   setup() {
-    return createSystemEvent('Setup', this, () => {
+    return eventEmitter.emit('setup', this).then(() => {
       const entities = this.models.filter(m => m.isEntity());
 
       // Create model indexes
@@ -37,10 +37,18 @@ module.exports = class extends Schema {
     });
   }
 
+  disconnect() {
+    return Promise.all(Object.values(this.drivers).map(({ dao }) => dao.disconnect()));
+  }
+
   initialize() {
     super.initialize();
     this.models = super.getModels().map(model => new Model(this, model, this.drivers[model.getDriverName()]));
-    this.models.forEach(model => model.initialize());
+    return this;
+  }
+
+  finalize() {
+    super.finalize();
     this.models.forEach(model => model.referentialIntegrity(identifyOnDeletes(this.models, model)));
     return this;
   }

package/src/data/DataLoader.js

@@ -42,8 +42,6 @@ module.exports = class DataLoader extends FBDataLoader {
        */
       const whereShape = model.getShape('create', 'where');
 
-      // console.log(Object.entries(batchQueries).map(([key, value]) => ({ [key]: value.length })));
-
       return Promise.all(Object.entries(batchQueries).map(([key, values]) => {
         switch (key) {
           case defaultBatchName: {
@@ -52,7 +50,7 @@ module.exports = class DataLoader extends FBDataLoader {
           default: {
             const keys = Array.from(new Set(values.map(({ where }) => map(where[key], el => `${el}`)).flat()));
             const batchQuery = new Query({ resolver, model, method: 'findMany', crud: 'read' });
-            const batchWhere = model.shapeObject(whereShape, { [key]: keys }, batchQuery); // This will add back instructs etc
+            const batchWhere = model.shapeObject(whereShape, { ...values[0].where, [key]: keys }, batchQuery); // All where's should be the same - this is for idKey on keys etc
 
             return driver.resolve(batchQuery.where(batchWhere).toDriver()).then(data => handleData(data, model, batchQuery)).then((results) => {
               // One-time data transformation on results to make matching back faster (below)

package/src/data/DataService.js

@@ -1,27 +1,50 @@
 const { get, remove } = require('lodash');
 const { map, isPlainObject, objectContaining, mergeDeep, ensureArray, keyPaths } = require('../service/app.service');
 
-exports.paginateResultSet = (rs, query) => {
+exports.finalizeResults = (rs, query) => {
+  const { model, resolver } = query.toObject();
+
+  return map(exports.paginateResults(rs, query), (doc) => {
+    return Object.defineProperties(doc, {
+      $model: { value: model },
+      $save: { value: input => resolver.match(model).id(doc.id).save({ ...doc, ...input }) },
+      $remove: { value: (...args) => resolver.match(model).id(doc.id).remove(...args) },
+      $delete: { value: (...args) => resolver.match(model).id(doc.id).delete(...args) },
+      $lookup: { value: (fieldName, args) => model.getFieldByName(fieldName).resolve(resolver, doc, args) },
+      // $resolve: { value: (fieldName, args) => model.getFieldByName(fieldName).resolve(resolver, doc, args, true) },
+    });
+  });
+};
+
+/**
+ * This is cursor-style pagination only
+ * You add 2 extra records to the result in order to determine previous/next
+ */
+exports.paginateResults = (rs, query) => {
   const { first, after, last, before, sort } = query.toObject();
-  const sortPaths = keyPaths(sort);
-  const limiter = first || last;
+  const isPaginating = Boolean(first || last || after || before);
+
+  // Return right away if not paginating
+  if (!isPaginating) return rs;
+
   let hasNextPage = false;
   let hasPreviousPage = false;
+  const limiter = first || last;
+  const sortPaths = keyPaths(sort);
 
-  // Add $$cursor data
+  // Add $cursor data
   map(rs, (doc) => {
     const sortValues = sortPaths.reduce((prv, path) => Object.assign(prv, { [path]: get(doc, path) }), {});
-    const sortJSON = JSON.stringify(sortValues);
-    doc.$$cursor = Buffer.from(sortJSON).toString('base64');
+    Object.defineProperty(doc, '$cursor', { get() { return Buffer.from(JSON.stringify(sortValues)).toString('base64'); } });
   });
 
   // First try to take off the "bookends" ($gte | $lte)
-  if (rs.length && rs[0].$$cursor === after) {
+  if (rs.length && rs[0].$cursor === after) {
     rs.shift();
     hasPreviousPage = true;
   }
 
-  if (rs.length && rs[rs.length - 1].$$cursor === before) {
+  if (rs.length && rs[rs.length - 1].$cursor === before) {
     rs.pop();
     hasNextPage = true;
   }
@@ -42,18 +65,17 @@ exports.paginateResultSet = (rs, query) => {
     }
   }
 
-  // Add $$pageInfo data (hidden)
+  // Add $pageInfo
   return Object.defineProperties(rs, {
-    $$pageInfo: {
+    $pageInfo: {
       get() {
         return {
-          startCursor: get(rs, '0.$$cursor', ''),
-          endCursor: get(rs, `${rs.length - 1}.$$cursor`, ''),
+          startCursor: get(rs, '0.$cursor', ''),
+          endCursor: get(rs, `${rs.length - 1}.$cursor`, ''),
           hasPreviousPage,
           hasNextPage,
         };
       },
-      enumerable: false,
     },
   });
 };

package/src/data/Field.js

@@ -1,9 +1,7 @@
 const { isEmpty } = require('lodash');
 const Type = require('./Type');
 const Field = require('../graphql/ast/Field');
-const Boom = require('../core/Boom');
 const Pipeline = require('./Pipeline');
-const { isPlainObject, ensureArray } = require('../service/app.service');
 
 module.exports = class extends Field {
   constructor(model, field) {
@@ -15,49 +13,34 @@ module.exports = class extends Field {
   getStructures() {
     // Grab structures from the underlying type
     const structures = this.type.getStructures();
-    const { isRequired, isPersistable, isVirtual, isPrimaryKeyId, isIdField } = this.props;
+    const { type, isPrimaryKeyId, isIdField, isRequired, isPersistable, isVirtual, isEmbedded, modelRef } = this.props;
 
     // Structures defined on the field
     const $structures = Object.entries(this.getDirectiveArgs('field', {})).reduce((prev, [key, value]) => {
       if (!Array.isArray(value)) value = [value];
-      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]));
+      if (key === 'validate') prev.validators.push(...value.map(t => Pipeline[t]));
+      if (key === 'instruct') prev.instructs.push(...value.map(t => Pipeline[t]));
+      if (key === 'restruct') prev.restructs.push(...value.map(t => Pipeline[t]));
+      if (key === 'destruct') prev.destructs.push(...value.map(t => Pipeline[t]));
+      if (key === 'construct') prev.constructs.push(...value.map(t => Pipeline[t]));
+      if (key === 'transform') prev.transforms.push(...value.map(t => Pipeline[t]));
+      if (key === 'normalize') prev.normalizers.push(...value.map(t => Pipeline[t]));
+      if (key === 'serialize') prev.serializers.push(...value.map(t => Pipeline[t]));
+      if (key === 'deserialize') prev.deserializers.push(...value.map(t => Pipeline[t]));
       return prev;
     }, structures);
 
     // IDs (first - shift)
-    if (isPrimaryKeyId) $structures.serializers.unshift(Pipeline.idKey);
+    if (isPrimaryKeyId && type === 'ID') $structures.serializers.unshift(Pipeline.idKey);
     if (isIdField) $structures.$serializers.unshift(Pipeline.idField);
 
     // Required (last - push)
-    if (isRequired && isPersistable && !isVirtual) $structures.serializers.push(Pipeline.required);
+    if (isRequired && isPersistable && !isVirtual) $structures.validators.push(Pipeline.required);
+    if (modelRef && !isEmbedded) $structures.validators.push(Pipeline.ensureId);
 
     return $structures;
   }
 
-  async validate(query, value) {
-    if (value == null) return value;
-    const { resolver } = query.toObject();
-    const { type, modelRef, isEmbedded } = this.props;
-
-    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 && isPlainObject(ensureArray(value)[0])) return modelRef.validate(query, value); // Model delegation
-
-    return value;
-  }
-
   resolve(resolver, doc, args = {}) {
     const { name, isArray, isScalar, isVirtual, isRequired, isEmbedded, modelRef, virtualField } = this.props;
     const value = doc[name];

package/src/data/Model.js

@@ -1,10 +1,9 @@
 const Stream = require('stream');
 const Field = require('./Field');
-const Pipeline = require('./Pipeline');
 const Model = require('../graphql/ast/Model');
-const { paginateResultSet } = require('./DataService');
 const { eventEmitter } = require('../service/event.service');
-const { map, seek, deseek, ensureArray } = require('../service/app.service');
+const { finalizeResults } = require('./DataService');
+const { map, mapPromise, seek, deseek } = require('../service/app.service');
 
 module.exports = class extends Model {
   constructor(schema, model, driver) {
@@ -48,80 +47,86 @@ 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);
-    });
-  }
-
   /**
    * Convenience method to deserialize data from a data source (such as a database)
    */
   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);
+        resolve(this.shapeObject(shape, mixed, query));
       } else {
         const results = [];
-        mixed.on('data', (data) => { results.push(pipeline ? this.shapeObject(shape, data, query) : data); });
+        mixed.on('data', (data) => { results.push(this.shapeObject(shape, data, query)); });
         mixed.on('end', () => { resolve(results); });
         mixed.on('error', reject);
       }
-    }).then((results) => {
-      return results.length && pipeline ? paginateResultSet(results, query) : results;
-    });
+    }).then(rs => finalizeResults(rs, query));
   }
 
   getShape(crud = 'read', target = 'doc', paths = []) {
+    // Cache check
     const cacheKey = `${crud}:${target}`;
     if (this.shapesCache.has(cacheKey)) return this.shapesCache.get(cacheKey);
 
     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 sortKeys = ['isIdField', 'isBasicType', 'isEmbedded'];
     const crudKeys = crudMap[crud] || [];
 
+    // Define target mapping
     const targetMap = {
-      doc: ['defaultValue', 'ensureArrayValue', 'castValue', ...crudKeys, `$${serdes}rs`, 'instructs', 'transformers', `${serdes}rs`],
-      where: ['castValue', `$${serdes}rs`, 'instructs'],
+      doc: ['defaultValue', 'castValue', 'ensureArrayValue', 'normalizers', 'instructs', ...crudKeys, `$${serdes}rs`, `${serdes}rs`, 'transforms'],
+      input: ['defaultValue', 'castValue', 'ensureArrayValue', 'normalizers', 'instructs', ...crudKeys, `$${serdes}rs`, `${serdes}rs`, 'transforms'],
+      // input: ['defaultValue', 'castValue', 'ensureArrayValue'],
+      where: ['castValue', 'instructs', `$${serdes}rs`],
     };
 
     const structureKeys = targetMap[target] || ['castValue'];
 
-    // Create shape, recursive
-    const shape = fields.map((field) => {
+    // Create sorted shape, recursive
+    const shape = fields.sort((a, b) => {
+      const aObject = a.toObject();
+      const bObject = b.toObject();
+
+      // PK first
+      if (aObject.isPrimaryKeyId) return -1;
+      if (bObject.isPrimaryKeyId) return 1;
+
+      // Arrays last
+      if (aObject.isArray && !bObject.isArray) return 1;
+      if (bObject.isArray && !aObject.isArray) return -1;
+
+      // Now, follow sort keys
+      const aNum = sortKeys.findIndex(key => aObject[key]);
+      const bNum = sortKeys.findIndex(key => bObject[key]);
+      if (aNum < bNum) return -1;
+      if (aNum > bNum) return 1;
+      return 0;
+    }).map((field) => {
+      let instructed = false;
       const structures = field.getStructures();
-      const [key, name, type, isArray] = [field.getKey(), field.getName(), field.getType(), field.isArray(), field.isIdField()];
+      const { key, name, type, isArray, isEmbedded, modelRef } = field.toObject();
       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;
-
-      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 };
+      const actualTo = target === 'input' || target === 'splice' ? from : to;
+      const path = paths.concat(actualTo);
+      const subCrud = crud === 'update' && isArray ? 'create' : crud; // Due to limitation to update embedded array
+      const subShape = isEmbedded ? modelRef.getShape(subCrud, target, path) : null;
+      const transformers = structureKeys.reduce((prev, struct) => {
+        const structs = structures[struct];
+        if (struct === 'instructs' && structs.length) instructed = true;
+        return prev.concat(structs);
+      }, []).filter(Boolean);
+      return { instructed, field, path, from, to: actualTo, type, isArray, transformers, validators: structures.validators, shape: subShape };
     });
 
     // Adding useful shape info
     shape.crud = crud;
     shape.model = this;
     shape.serdes = serdes;
+    shape.target = target;
 
     // Cache and return
     this.shapesCache.set(cacheKey, shape);
@@ -130,7 +135,11 @@ module.exports = class extends Model {
 
   shapeObject(shape, obj, query, root) {
     const { serdes, model } = shape;
-    const { context, doc = {} } = query.toObject();
+    const { context, resolver, doc = {}, flags = {} } = query.toObject();
+    const { pipeline } = flags;
+
+    if (!pipeline) return obj;
+    // const filters = pipeline === true ? [] : Object.entries(pipeline).map(([k, v]) => (v === false ? k : null)).filter(Boolean);
 
     return map(obj, (parent) => {
       // "root" is the base of the object
@@ -141,19 +150,19 @@ module.exports = class extends Model {
       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));
 
-      return shape.reduce((prev, { field, from, to, path, type, isArray, defaultValue, transformers = [], shape: subShape }) => {
+      return shape.reduce((prev, { instructed, field, from, to, path, type, isArray, defaultValue, transformers = [], shape: subShape }) => {
         const startValue = parent[from];
+        // transformers = filters.length ? transformers.filter() : transformers;
 
         // Transform value
         const transformedValue = transformers.reduce((value, t) => {
-          const v = t({ model, field, path, docPath, rootPath, parentPath, startValue, value, context });
+          const v = t({ model, field, path, docPath, rootPath, parentPath, startValue, value, resolver, context });
           return v === undefined ? value : v;
         }, startValue);
 
-        // if (`${field}` === 'searchability') console.log(startValue, transformedValue, transformers);
-
         // Determine if key should stay or be removed
-        if (transformedValue === undefined && !Object.prototype.hasOwnProperty.call(parent, from)) return prev;
+        if (!instructed && transformedValue === undefined && !Object.prototype.hasOwnProperty.call(parent, from)) return prev;
+        if (!instructed && subShape && typeof transformedValue !== 'object') return prev;
 
         // Rename key & assign value
         prev[to] = (!subShape || transformedValue == null) ? transformedValue : this.shapeObject(subShape, transformedValue, query, root);
@@ -162,4 +171,36 @@ module.exports = class extends Model {
       }, {});
     });
   }
+
+  validateObject(shape, obj, query, root, silent = false) {
+    const { model } = shape;
+    const { context, resolver, doc = {}, flags = {} } = query.toObject();
+    const { validate = true } = flags;
+
+    if (!validate) return Promise.resolve();
+
+    return mapPromise(obj, (parent) => {
+      // "root" is the base of the object
+      root = root || parent;
+
+      // Lookup helper functions
+      const docPath = (p, hint) => seek(doc, p, hint);
+      const rootPath = (p, hint) => seek(root, p, hint);
+      const parentPath = (p, hint) => seek(parent, p, hint);
+
+      return Promise.all(shape.map(({ field, from, path, validators, shape: subShape }) => {
+        const value = parent[from]; // It hasn't been shaped yet
+
+        return Promise.all(validators.map((v) => {
+          return new Promise((resolve, reject) => {
+            return Promise.resolve(v({ model, field, path, docPath, rootPath, parentPath, startValue: value, value, resolver, context })).then(resolve).catch(reject);
+          });
+        })).then(() => {
+          return subShape ? this.validateObject(subShape, value, query, root, true) : Promise.resolve();
+        });
+      }));
+    }).then(() => {
+      return silent ? Promise.resolve() : eventEmitter.emit('validate', query.toObject());
+    });
+  }
 };

package/src/data/Pipeline.js

@@ -1,5 +1,5 @@
 const { uniqWith } = require('lodash');
-const { map, hashObject } = require('../service/app.service');
+const { map, ensureArray, hashObject } = require('../service/app.service');
 const Boom = require('../core/Boom');
 
 module.exports = class Pipeline {
@@ -29,17 +29,17 @@ module.exports = class Pipeline {
     }, 'name', { value: name });
 
     // Attach enumerable method to the Pipeline
-    Object.defineProperty(Pipeline, name, {
+    return Object.defineProperty(Pipeline, name, {
       value: wrapper,
       configurable,
       enumerable: true,
-    });
+    })[name];
   }
 
   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 }) });
+    return Object.defineProperty(Pipeline, name, { value: (...args) => Object.defineProperty(thunk(...args), 'options', { value: options }) })[name];
   }
 
   // static wrapper(name, factory, { ignoreNull, itemize }) {
@@ -66,13 +66,24 @@ module.exports = class Pipeline {
     // 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('toId', ({ model, value }) => model.idValue(value));
     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('idField', ({ model, field, value }) => field.getIdModel().idValue(value.id || value));
+    Pipeline.define('ensureArrayValue', ({ field, value }) => (field.toObject().isArray && !Array.isArray(value) ? [value] : value), { itemize: false });
+
+    Pipeline.define('ensureId', ({ resolver, field, value }) => {
+      const { type } = field.toObject();
+      const ids = Array.from(new Set(ensureArray(value).map(v => `${v}`)));
+
+      return resolver.match(type).where({ id: ids }).count().then((count) => {
+        if (count !== ids.length) throw Boom.notFound(`${type} Not Found`);
+      });
+    }, { itemize: false });
 
     Pipeline.define('defaultValue', ({ field, value }) => {
       const { defaultValue } = field.toObject();
@@ -117,7 +128,7 @@ module.exports = class Pipeline {
     }, { ignoreNull: false });
 
     // A field cannot hold a reference to itself
-    Pipeline.define('selfless', ({ model, field, parentPath, value }) => {
+    Pipeline.define('selfless', ({ model, field, parent, parentPath, value }) => {
       if (`${value}` === `${parentPath('id')}`) throw Boom.badRequest(`${model}.${field} cannot hold a reference to itself`);
     });
 
@@ -129,17 +140,17 @@ module.exports = class Pipeline {
     });
 
     // List of allowed values
-    Pipeline.factory('allow', (...args) => function allow({ model, field, value }) {
+    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 }) {
+    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) => {
+    Pipeline.factory('Range', (min, max) => {
       if (min == null) min = undefined;
       if (max == null) max = undefined;
 
@@ -152,7 +163,6 @@ module.exports = class Pipeline {
   }
 };
 
-
 // const jsStringMethods = [
 //   'charAt', 'charCodeAt', 'codePointAt', 'concat', 'indexOf', 'lastIndexOf', 'localeCompare',
 //   'normalize', 'padEnd', 'padStart', 'repeat', 'replace', 'search', 'slice', 'split', 'substr', 'substring',