@coderich/autograph 0.10.2 → 0.10.3

package/CHANGELOG.md

@@ -2,27 +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)
-- Must pass makeExecutableSchema to Schema constructor
+- 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.2",
+  "version": "0.10.3",
   "description": "AutoGraph",
   "keywords": [
     "graphql",
@@ -31,7 +31,6 @@
   },
   "dependencies": {
     "@hapi/boom": "^9.1.0",
-    "axios": "^0.21.4",
     "dataloader": "^2.0.0",
     "deepmerge": "^4.2.2",
     "fill-range": "^7.0.1",
@@ -40,12 +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": "^8.3.14",
+    "@graphql-tools/schema": "^9.0.1",
     "graphql": "^15.5.0",
     "mongodb-memory-server": "^8.7.2",
     "neo4j-driver": "^4.0.0",
@@ -54,6 +52,9 @@
     "redis-mock": "^0.47.0",
     "validator": "^13.7.0"
   },
+  "peerDependencies": {
+    "graphql": "*"
+  },
   "repository": {
     "type": "git",
     "url": "git@github.com:coderich/autograph.git"

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,12 +1,12 @@
 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 {
-  constructor(schema, stores, toExecutableSchema) {
-    super(schema, toExecutableSchema);
+  constructor(schema, stores) {
+    super(schema);
 
     // Create drivers
     this.drivers = Object.entries(stores).reduce((prev, [key, value]) => {
@@ -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

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,45 +47,26 @@ 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);
 
@@ -95,33 +75,39 @@ module.exports = class extends Model {
     const crudMap = { create: ['constructs'], update: ['restructs'], delete: ['destructs'], remove: ['destructs'] };
     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) => {
+      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) => {
+        if (instructed) return prev;
+        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 +116,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 +131,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 +152,32 @@ 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 => v({ model, field, path, docPath, rootPath, parentPath, startValue: value, value, resolver, context }))).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',

package/src/data/Type.js

@@ -11,20 +11,39 @@ module.exports = class extends Type {
     const type = this.field.getType();
     const enumType = this.field.getEnumRef();
     const scalarType = this.field.getScalarRef();
-    const structures = { instructs: [], restructs: [], destructs: [], constructs: [], $serializers: [], serializers: [], $deserializers: [], deserializers: [], transformers: [] };
+    const structures = {
+      validators: [],
+      instructs: [],
+      restructs: [],
+      destructs: [],
+      constructs: [],
+      normalizers: [],
+      $serializers: [],
+      $deserializers: [],
+      serializers: [],
+      deserializers: [],
+      transforms: [],
+    };
 
-    if (enumType) structures.serializers.push(Pipeline.define(`$allow:${type}`, Pipeline.allow(...enumType.getValue()), { configurable: true }));
+    // Built-in pipelines
+    structures.castValue = Pipeline.castValue;
+    structures.defaultValue = Pipeline.defaultValue;
+    structures.ensureArrayValue = Pipeline.ensureArrayValue;
+
+    if (enumType) structures.validators.push(Pipeline.define(`allow:${type}`, Pipeline.Allow(...enumType.getValue()), { configurable: true }));
     if (!scalarType) return structures;
 
     return Object.entries(scalarType.getDirectiveArgs('field', {})).reduce((prev, [key, value]) => {
       if (!Array.isArray(value)) value = [value];
+      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]));
-      if (key === 'transform') prev.transformers.push(...value.map(t => Pipeline[t]));
       return prev;
     }, structures);
   }

package/src/driver/MongoDriver.js

@@ -1,6 +1,6 @@
 const Util = require('util');
 const { get } = require('lodash');
-const { MongoClient, ObjectID } = require('mongodb');
+const { MongoClient, ObjectId } = require('mongodb');
 const { map, ensureArray, proxyDeep, toKeyObj, globToRegex, proxyPromise, isScalarDataType, promiseRetry } = require('../service/app.service');
 
 module.exports = class MongoDriver {
@@ -126,10 +126,10 @@ module.exports = class MongoDriver {
   }
 
   static idValue(value) {
-    if (value instanceof ObjectID) return value;
+    if (value instanceof ObjectId) return value;
 
     try {
-      const id = ObjectID(value);
+      const id = ObjectId(value);
       return id;
     } catch (e) {
       return value;
@@ -142,7 +142,10 @@ module.exports = class MongoDriver {
         const value = Reflect.get(target, prop, rec);
         if (typeof value === 'function') return value.bind(target);
         const $value = map(value, v => (typeof v === 'string' ? globToRegex(v, { nocase: true, regex: true }) : v));
-        if (Array.isArray($value)) return { $in: $value };
+        if (Array.isArray($value)) {
+          // console.log(Util.inspect({ value, $value }, { depth: null, showHidden: false, colors: true }));
+          return { $in: $value };
+        }
         return $value;
       },
     }).toObject();

package/src/graphql/ast/Field.js

@@ -175,8 +175,10 @@ module.exports = class Field extends Node {
 
   initialize() {
     this.props = {
+      key: this.getKey(),
       name: this.getName(),
       type: this.getType(),
+      model: this.model,
       datatype: this.getDataType(),
       defaultValue: this.getDefaultValue(),
       isArray: this.isArray(),
@@ -187,6 +189,7 @@ module.exports = class Field extends Node {
       isIdField: this.isIdField(),
       isPrimaryKeyId: this.isPrimaryKeyId(),
       isPersistable: this.isPersistable(),
+      idModel: this.getIdModel(),
       modelRef: this.getModelRef(),
       virtualRef: this.getVirtualRef(),
       virtualField: this.getVirtualField(),

package/src/graphql/ast/Schema.js

@@ -24,9 +24,8 @@ const Node = require('./Node');
  *
  */
 module.exports = class Schema extends TypeDefApi {
-  constructor(schema, toExecutableSchema) {
+  constructor(schema) {
     super();
-    this.toExecutableSchema = toExecutableSchema;
     this.schema = { typeDefs: [], resolvers: {}, schemaDirectives: {} };
     if (schema) this.mergeSchema(schema);
   }
@@ -121,13 +120,10 @@ module.exports = class Schema extends TypeDefApi {
     });
 
     this.schema.typeDefs = { kind: Kind.DOCUMENT, definitions };
+    // validateSchema(this.schema);
     return this;
   }
 
-  makeExecutableSchema() {
-    return this.toExecutableSchema(this.schema);
-  }
-
   toObject() {
     return this.schema;
   }

package/src/graphql/extension/api.js

@@ -163,8 +163,8 @@ module.exports = (schema) => {
         [modelName]: fieldResolvers,
         [`${modelName}Connection`]: {
           count: ({ count }) => count(),
-          edges: ({ edges }) => edges().then(rs => rs.map(node => ({ cursor: get(node, '$$cursor'), node }))),
-          pageInfo: ({ pageInfo }) => pageInfo().then(rs => get(rs, '$$pageInfo')),
+          edges: ({ edges }) => edges().then(rs => rs.map(node => ({ cursor: get(node, '$cursor'), node }))),
+          pageInfo: ({ pageInfo }) => pageInfo().then(rs => get(rs, '$pageInfo')),
         },
       });
     }, {

package/src/graphql/extension/framework.js

@@ -31,11 +31,11 @@ module.exports = (schema) => {
 
       directive @field(
         id: String # Specify the ModelRef this field FK References
+        ref: AutoGraphMixed # Specify the modelRef field's name (overrides isEmbedded)
         key: String # Specify db key
         persist: Boolean # Persist this field (default true)
         connection: Boolean # Treat this field as a connection type (default false - rolling this out slowly)
         default: AutoGraphMixed # Define a default value
-        ref: AutoGraphMixed # Specify the modelRef field's name (overrides isEmbedded)
         gqlScope: AutoGraphMixed # Dictate how GraphQL API behaves
         dalScope: AutoGraphMixed # Dictate how the DAL behaves
         fieldScope: AutoGraphMixed # Dictate how a FIELD may use me
@@ -44,13 +44,15 @@ module.exports = (schema) => {
         authz: AutoGraphAuthzEnum # Access level used for authorization (default: private)
 
         # Pipeline Structure
+        validate: [AutoGraphPipelineEnum!]
         instruct: [AutoGraphPipelineEnum!]
-        destruct: [AutoGraphPipelineEnum!]
         restruct: [AutoGraphPipelineEnum!]
+        destruct: [AutoGraphPipelineEnum!]
         construct: [AutoGraphPipelineEnum!]
+        transform: [AutoGraphPipelineEnum!]
+        normalize: [AutoGraphPipelineEnum!]
         serialize: [AutoGraphPipelineEnum!]
         deserialize: [AutoGraphPipelineEnum!]
-        transform: [AutoGraphPipelineEnum!]
       ) on FIELD_DEFINITION | INPUT_FIELD_DEFINITION | SCALAR
 
       directive @link(

package/src/graphql/extension/type.js

@@ -17,7 +17,7 @@ module.exports = (schema) => {
         return `
           extend type ${modelName}${interfacesGQL} {
             ${id ? `id: ID! @field(key: "${id}", gqlScope: r)` : ''}
-            ${createdAt ? `createdAt: AutoGraphDateTime @field(key: "${createdAt}", serialize: createdAt, gqlScope: r)` : ''}
+            ${createdAt ? `createdAt: AutoGraphDateTime @field(key: "${createdAt}", construct: createdAt, gqlScope: r)` : ''}
             ${updatedAt ? `updatedAt: AutoGraphDateTime @field(key: "${updatedAt}", serialize: timestamp, gqlScope: r)` : ''}
           }
         `;

package/src/query/Query.js

@@ -272,6 +272,16 @@ module.exports = class Query {
     return this;
   }
 
+  payload(payload) {
+    this.props.payload = payload;
+    return this;
+  }
+
+  result(result) {
+    this.props.result = result;
+    return this;
+  }
+
   $doc($doc) {
     this.props.$doc = $doc;
     return this;

package/src/query/QueryResolver.js

@@ -16,7 +16,7 @@ module.exports = class QueryResolver {
     const { args } = query.toObject();
     const [,,, info] = args;
 
-    switch (getGQLReturnType(info.returnType)) {
+    switch (getGQLReturnType(`${info.returnType}`)) {
       case 'array': {
         return new QueryResolver(this.query.clone().method('findMany')).resolve();
       }
@@ -36,42 +36,35 @@ module.exports = class QueryResolver {
     }
   }
 
-  async findOne(query) {
-    await QueryService.resolveQuery(query);
-
-    return createSystemEvent('Query', { query }, () => {
+  findOne(query) {
+    return createSystemEvent('Query', { query }, async () => {
       return this.resolver.resolve(query);
     });
   }
 
-  async findMany(query) {
-    await QueryService.resolveQuery(query);
-
-    return createSystemEvent('Query', { query }, () => {
+  findMany(query) {
+    return createSystemEvent('Query', { query }, async () => {
       return this.resolver.resolve(query);
     });
   }
 
-  async count(query) {
-    await QueryService.resolveQuery(query);
-
-    return createSystemEvent('Query', { query }, () => {
+  count(query) {
+    return createSystemEvent('Query', { query }, async () => {
       return this.resolver.resolve(query);
     });
   }
 
-  async createOne(query) {
+  createOne(query) {
     const { model, input } = query.toObject();
-    const shape = model.getShape('create');
-
-    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;
+    const inputShape = model.getShape('create', 'input');
+    const docShape = model.getShape('create', 'doc');
+    const doc = model.shapeObject(inputShape, {}, query); // We use input shape here
+    const merged = mergeDeep(doc, input);
+
+    return createSystemEvent('Mutation', { query: query.doc(doc).merged(merged) }, async () => {
+      const payload = model.shapeObject(inputShape, merged, query);
+      await model.validateObject(inputShape, payload, query.payload(payload));
+      return this.resolver.resolve(query.$input(model.shapeObject(docShape, payload, query)));
     });
   }
 
@@ -84,17 +77,16 @@ module.exports = class QueryResolver {
 
   async updateOne(query) {
     const { model, match, input } = query.toObject();
+    const inputShape = model.getShape('update', 'input');
+    const docShape = model.getShape('update', 'doc');
 
-    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);
-
-      await QueryService.resolveQuery(query);
+    return this.resolver.match(model).match(match).one({ required: true }).then((doc) => {
+      const merged = mergeDeep(doc, 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));
+        const payload = model.shapeObject(inputShape, merged, query);
+        await model.validateObject(inputShape, payload, query.payload(payload));
+        return this.resolver.resolve(query.$doc(model.shapeObject(docShape, payload, query)));
       });
     });
   }
@@ -110,11 +102,9 @@ 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(async (doc) => {
-      await QueryService.resolveQuery(query);
+    const { model, id } = query.toObject();
 
+    return this.resolver.match(model).id(id).one({ required: true }).then(async (doc) => {
       return createSystemEvent('Mutation', { query: query.doc(doc) }, () => {
         return QueryService.resolveReferentialIntegrity(query).then(() => {
           return this.resolver.resolve(query).then(() => doc);
@@ -186,7 +176,10 @@ module.exports = class QueryResolver {
   }
 
   splice(query) {
-    const { model, match, args, flags = {} } = query.toObject();
+    const { model, match, args } = query.toObject();
+    const docShape = model.getShape('update', 'doc');
+    const inputShape = model.getShape('update', 'input');
+    const spliceShape = model.getShape('update', 'splice');
     const [key, from, to] = args;
 
     // Can only splice arrays
@@ -194,20 +187,16 @@ module.exports = class QueryResolver {
     const isArray = field.isArray();
     if (!isArray) throw Boom.badRequest(`Cannot splice field '${model}.${field}'`);
 
-    return this.resolver.match(model).match(match).flags(flags).one({ required: true }).then(async (doc) => {
+    return this.resolver.match(model).match(match).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;
+      const $to = model.shapeObject(spliceShape, { [key]: to }, query)[key] || to;
+      const $from = model.shapeObject(spliceShape, { [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));
+        const payload = model.shapeObject(inputShape, doc, query);
+        await model.validateObject(inputShape, payload, query.payload(payload));
+        return this.resolver.resolve(query.$doc(model.shapeObject(docShape, payload, query)));
       });
     });
   }
@@ -223,9 +212,6 @@ module.exports = class QueryResolver {
   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 && isEmpty(data)) throw Boom.notFound(`${model} Not Found`);
       if (data == null) return null; // Explicitly return null here

package/src/query/QueryService.js

@@ -6,7 +6,7 @@ const { keyPaths, ensureArray, isPlainObject } = require('../service/app.service
  * 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 { resolver, model, match: where = {} } = query.toObject();
   const shape = model.getShape('create', 'where');
 
   const $where = Object.entries(where).reduce((prev, [from, value]) => {
@@ -16,12 +16,12 @@ exports.resolveWhereClause = (query) => {
     const { isVirtual, isEmbedded, modelRef, virtualRef } = el.field.toObject();
 
     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)));
+      const ids = Promise.all(ensureArray(value).map(v => resolver.match(modelRef).where(isPlainObject(v) ? v : { id: v }).many().then(docs => docs.map(doc => doc[virtualRef])))).then(results => uniq(flattenDeep(results)));
       return Object.assign(prev, { id: ids });
     }
 
     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)));
+      const ids = Promise.all(ensureArray(value).map(v => (isPlainObject(v) ? resolver.match(modelRef).where(v).many().then(docs => docs.map(doc => doc.id)) : Promise.resolve(v)))).then(results => uniq(flattenDeep(results)));
       return Object.assign(prev, { [from]: ids });
     }
 
@@ -67,7 +67,7 @@ exports.resolveSortBy = (query) => {
 };
 
 exports.resolveReferentialIntegrity = (query) => {
-  const { id, model, resolver, transaction, flags } = query.toObject();
+  const { id, model, resolver, transaction } = query.toObject();
   const txn = resolver.transaction(transaction);
 
   return new Promise((resolve, reject) => {
@@ -79,18 +79,18 @@ exports.resolveReferentialIntegrity = (query) => {
         switch (op) {
           case 'cascade': {
             if (isArray) {
-              txn.match(ref).where($where).flags(flags).pull(fieldStr, id);
+              txn.match(ref).where($where).pull(fieldStr, id);
             } else {
-              txn.match(ref).where($where).flags(flags).remove();
+              txn.match(ref).where($where).remove();
             }
             break;
           }
           case 'nullify': {
-            txn.match(ref).where($where).flags(flags).save({ [fieldStr]: null });
+            txn.match(ref).where($where).save({ [fieldStr]: null });
             break;
           }
           case 'restrict': {
-            txn.match(ref).where($where).flags(flags).count().then(count => (count ? reject(new Error('Restricted')) : count));
+            txn.match(ref).where($where).count().then(count => (count ? reject(new Error('Restricted')) : count));
             break;
           }
           case 'defer': {
@@ -109,18 +109,3 @@ 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

@@ -2,7 +2,7 @@ const _ = require('lodash');
 const PicoMatch = require('picomatch');
 const FillRange = require('fill-range');
 const DeepMerge = require('deepmerge');
-const { ObjectID } = require('mongodb');
+const { ObjectId } = require('mongodb');
 const ObjectHash = require('object-hash');
 
 // const combineMerge = (target, source, options) => {
@@ -32,15 +32,15 @@ exports.id = '3d896496-02a3-4ee5-8e42-2115eb215f7e';
 exports.ucFirst = string => string.charAt(0).toUpperCase() + string.slice(1);
 exports.lcFirst = string => string.charAt(0).toLowerCase() + string.slice(1);
 exports.isNumber = value => typeof value === 'number' && Number.isFinite(value);
-exports.isBasicObject = obj => obj != null && typeof obj === 'object' && !(ObjectID.isValid(obj)) && !(obj instanceof Date) && typeof (obj.then) !== 'function';
+exports.isBasicObject = obj => obj != null && typeof obj === 'object' && !(ObjectId.isValid(obj)) && !(obj instanceof Date) && typeof (obj.then) !== 'function';
 exports.isPlainObject = obj => exports.isBasicObject(obj) && !Array.isArray(obj);
 exports.isScalarValue = value => typeof value !== 'object' && typeof value !== 'function';
 exports.isScalarDataType = value => ['String', 'Float', 'Int', 'Boolean', 'DateTime'].indexOf(value) > -1;
-exports.isIdValue = value => exports.isScalarValue(value) || value instanceof ObjectID;
+exports.isIdValue = value => exports.isScalarValue(value) || value instanceof ObjectId;
 exports.mergeDeep = (...args) => DeepMerge.all(args, { isMergeableObject: obj => (exports.isPlainObject(obj) || Array.isArray(obj)), arrayMerge: smartMerge });
 exports.uniq = arr => [...new Set(arr.map(a => `${a}`))];
 exports.timeout = ms => new Promise(res => setTimeout(res, ms));
-exports.hashObject = obj => ObjectHash(obj, { respectType: false, respectFunctionNames: false, respectFunctionProperties: false, unorderedArrays: true, ignoreUnknown: true, replacer: r => (r instanceof ObjectID ? `${r}` : r) });
+exports.hashObject = obj => ObjectHash(obj, { respectType: false, respectFunctionNames: false, respectFunctionProperties: false, unorderedArrays: true, ignoreUnknown: true, replacer: r => (r instanceof ObjectId ? `${r}` : r) });
 exports.globToRegex = (glob, options = {}) => PicoMatch.makeRe(glob, { ...options, expandRange: (a, b) => `(${FillRange(a, b, { toRegex: true })})` });
 exports.globToRegexp = (glob, options = {}) => PicoMatch.toRegex(exports.globToRegex(glob, options));
 exports.toGUID = (model, id) => Buffer.from(`${model},${`${id}`}`).toString('base64');
@@ -95,8 +95,7 @@ exports.map = (mixed, fn) => {
   if (mixed == null) return mixed;
   const isArray = Array.isArray(mixed);
   const arr = isArray ? mixed : [mixed];
-  // const results = arr.map((...args) => fn(...args));
-  const results = arr.map((el, i, a) => fn(el, isArray ? i : undefined, isArray ? a : undefined));
+  const results = isArray ? arr.map((...args) => fn(...args)) : arr.map(el => fn(el));
   return isArray ? results : results[0];
 };
 
@@ -105,6 +104,32 @@ exports.mapPromise = (mixed, fn) => {
   return Array.isArray(map) ? Promise.all(map) : Promise.resolve(map);
 };
 
+exports.castCmp = (type, value) => {
+  switch (type) {
+    case 'String': {
+      return `${value}`;
+    }
+    case 'Float': case 'Number': {
+      const num = Number(value);
+      if (!Number.isNaN(num)) return num;
+      return value;
+    }
+    case 'Int': {
+      const num = Number(value);
+      if (!Number.isNaN(num)) return parseInt(value, 10);
+      return value;
+    }
+    case 'Boolean': {
+      if (value === 'true') return true;
+      if (value === 'false') return false;
+      return value;
+    }
+    default: {
+      return value;
+    }
+  }
+};
+
 exports.objectContaining = (a, b) => {
   if (a === b) return true;
 

package/src/service/event.service.js

@@ -1,3 +1,4 @@
+const QueryService = require('../query/QueryService');
 const EventEmitter = require('../core/EventEmitter');
 const { ucFirst } = require('./app.service');
 
@@ -8,19 +9,49 @@ const systemEvent = new EventEmitter().setMaxListeners(100).on('system', async (
   next(await eventEmitter.emit(type, data)); // Return result from user-defined middleware
 });
 
+const makeEvent = (mixed) => {
+  const { query } = mixed;
+  const event = query.toObject();
+  event.query = query;
+  return event;
+};
+
+const makeMiddleware = () => {
+  return (mixed) => {
+    const { query } = mixed;
+    const { model, native, sort, match, batch } = query.toObject();
+
+    return new Promise(async (resolve) => {
+      if (!native) {
+        const whereShape = model.getShape('create', 'where');
+        const $where = batch ? match : await QueryService.resolveWhereClause(query);
+        const $$where = model.shapeObject(whereShape, $where, query);
+        query.match($$where);
+      }
+
+      if (sort) {
+        query.$sort(QueryService.resolveSortBy(query));
+      }
+
+      resolve();
+    });
+  };
+};
+
 //
 exports.createSystemEvent = (name, mixed = {}, thunk = () => {}) => {
   let event = mixed;
+  let middleware = () => Promise.resolve();
   const type = ucFirst(name);
 
-  if (name !== 'Setup' && name !== 'Response') {
-    const { query } = mixed;
-    event = query.toObject();
-    event.query = query;
+  if (name !== 'Response') {
+    event = makeEvent(mixed);
+    middleware = makeMiddleware();
   }
 
-  return systemEvent.emit('system', { type: `pre${type}`, data: event }).then((result) => {
-    return (result !== undefined) ? result : thunk(); // Allowing middleware to dictate result
+  return systemEvent.emit('system', { type: `pre${type}`, data: event }).then(async (result) => {
+    if (result !== undefined) return result; // Allowing middleware to dictate result
+    return middleware(mixed).then(thunk);
   }).then((result) => {
     event.result = result;
     if (event.crud === 'create') event.doc = event.query.toObject().doc;

package/src/core/GraphQL.js

@@ -1,21 +0,0 @@
-const { graphql } = require('graphql');
-
-/**
- * GraphQL.
- *
- * This is a wrapper class to the underlying GraphQL Executable Schema.
- * It can be useful for testing and/or exercising the API as an outside caller would.
- *
- * Reference: https://github.com/graphql/graphql-js/blob/master/src/graphql.js#L32-L33
- */
-module.exports = class GraphQL {
-  constructor(schema, resolver) {
-    this.schema = schema.makeExecutableSchema();
-    this.contextValue = resolver.getContext();
-  }
-
-  exec(source, variableValues) {
-    const { schema, contextValue = {} } = this;
-    return graphql({ schema, source, variableValues, contextValue });
-  }
-};