@coderich/autograph 0.10.1 → 0.10.4

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 {
@@ -64,15 +64,12 @@ module.exports = class MongoDriver {
   }
 
   createOne({ model, input, options, flags }) {
+    // console.log(JSON.stringify(input, null, 2));
     return this.query(model, 'insertOne', input, options, flags).then(result => Object.assign(input, { id: result.insertedId }));
   }
 
   updateOne({ model, where, $doc, options, flags }) {
-    const $update = Object.entries($doc).reduce((prev, [key, value]) => {
-      Object.assign(prev.$set, { [key]: value });
-      return prev;
-    }, { $set: {} });
-
+    const $update = { $set: $doc };
     return this.query(model, 'updateOne', where, $update, options, flags).then(() => $doc);
   }
 
@@ -126,10 +123,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 +139,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

@@ -173,20 +173,25 @@ module.exports = class Field extends Node {
     return this.getGQLType();
   }
 
-  initialize() {
+  finalize() {
     this.props = {
+      key: this.getKey(),
       name: this.getName(),
       type: this.getType(),
+      model: this.model,
       datatype: this.getDataType(),
       defaultValue: this.getDefaultValue(),
+      isEnum: this.isEnum(),
       isArray: this.isArray(),
       isScalar: this.isScalar(),
       isVirtual: this.isVirtual(),
       isRequired: this.isRequired(),
       isEmbedded: this.isEmbedded(),
+      isBasicType: this.isBasicType(),
       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/Model.js

@@ -138,8 +138,8 @@ module.exports = class Model extends Node {
     });
   }
 
-  initialize() {
-    this.fields.forEach(field => field.initialize());
+  finalize() {
+    this.fields.forEach(field => field.finalize());
     return this;
   }
 };

package/src/graphql/ast/Schema.js

@@ -2,7 +2,7 @@ const FS = require('fs');
 const Glob = require('glob');
 const Merge = require('deepmerge');
 const { Kind, print, parse, visit } = require('graphql');
-const { mergeASTArray, makeExecutableSchema } = require('../../service/graphql.service');
+const { mergeASTArray } = require('../../service/graphql.service');
 const { deleteKeys } = require('../../service/app.service');
 const frameworkExt = require('../extension/framework');
 const typeExt = require('../extension/type');
@@ -90,7 +90,6 @@ module.exports = class Schema extends TypeDefApi {
    */
   initialize() {
     super.initialize(this.schema.typeDefs);
-    this.getModels().forEach(model => model.initialize());
     return this;
   }
 
@@ -119,14 +118,11 @@ module.exports = class Schema extends TypeDefApi {
       },
     });
 
+    this.getModels().forEach(model => model.finalize());
     this.schema.typeDefs = { kind: Kind.DOCUMENT, definitions };
     return this;
   }
 
-  makeExecutableSchema() {
-    return makeExecutableSchema(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/QueryBuilder.js

@@ -10,6 +10,7 @@ const { unravelObject } = require('../service/app.service');
 */
 module.exports = class QueryBuilder {
   constructor(resolver, model) {
+    this.terminated = false; // Prevent accidental re-use of the QueryBuilder
     this.query = new Query({ model, resolver });
 
     // Chainable commands
@@ -57,6 +58,10 @@ module.exports = class QueryBuilder {
   }
 
   execute(cmd, args) {
+    // Do not allow re-use
+    if (this.terminated) return Promise.reject(new Error('This query has already been executed'));
+
+    this.terminated = true;
     let method, crud, input, flags = {};
     const { id, where } = this.query.toObject();
 

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];
 };
 

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/service/graphql.service.js

@@ -1,7 +1,5 @@
 const { get } = require('lodash');
 const { Kind, parse, print } = require('graphql');
-const { validate } = require('graphql/validation');
-const { makeExecutableSchema } = require('@graphql-tools/schema');
 
 //
 const mergePairs = [
@@ -81,13 +79,6 @@ exports.mergeASTArray = (arr) => {
   }, []).filter(el => !el.deleteFlag);
 };
 
-exports.validateSchema = (ast) => {
-  const errs = validate(makeExecutableSchema(ast), ast.typeDefs).filter(({ message }) => message.indexOf('not executable') === -1).map(({ message }) => message);
-  if (errs.length) throw new Error(errs.join('\n'));
-};
-
-exports.makeExecutableSchema = makeExecutableSchema;
-
 exports.toAST = (a) => {
   if (typeof a === 'string') return parse(a);
   if (Array.isArray(a)) return parse(a.map(e => exports.toGQL(e)).join('\n\n'));

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 });
-  }
-};