@coderich/autograph 0.9.16 → 0.10.2

package/src/query/Query.js

@@ -1,15 +1,21 @@
 const Boom = require('../core/Boom');
-const { unravelObject } = require('../service/app.service');
 
 module.exports = class Query {
   constructor(props = {}) {
     this.props = {};
     this.timers = {};
+    this.isCursorPaging = false;
+    this.isClassicPaging = false;
     this.props.joins = this.props.joins || [];
     this.props.match = this.props.match || {};
     this.props.options = this.props.options || {};
-    this.isClassicPaging = false;
-    this.isCursorPaging = false;
+    this.props.flags = this.props.flags || {
+      debug: false,
+      silent: false,
+      validate: true, // { externals }
+      pipeline: true, // { instruct, construct, destruct, restruct, serialize, deserialize, transform, rekey }
+      required: false,
+    };
     this.merge(props);
   }
 
@@ -22,12 +28,19 @@ module.exports = class Query {
   id(id) {
     this.propCheck('id', 'where', 'native', 'sort', 'skip', 'limit', 'before', 'after', 'first', 'last');
     this.props.id = id;
+    this.props.batch = 'id';
+    this.props.where = { id };
     return this.match({ id });
   }
 
+  batch(batch) {
+    this.props.batch = batch;
+    return this;
+  }
+
   where(where) {
     this.propCheck('where', 'id', 'native');
-    this.props.where = unravelObject(where);
+    this.props.where = where;
     return this.match(where);
   }
 
@@ -44,12 +57,12 @@ module.exports = class Query {
   }
 
   match(match) {
-    this.props.match = unravelObject(match);
+    this.props.match = match;
     return this;
   }
 
   select(select) {
-    this.props.select = unravelObject(select);
+    this.props.select = select;
     return this;
   }
 
@@ -70,7 +83,7 @@ module.exports = class Query {
 
   sort(sort) {
     this.propCheck('sort', 'id');
-    this.props.sort = unravelObject(sort);
+    this.props.sort = sort;
     return this;
   }
 
@@ -142,7 +155,7 @@ module.exports = class Query {
   }
 
   flags(flags) {
-    this.props.flags = flags;
+    Object.assign(this.props.flags, flags);
     return this;
   }
 
@@ -161,6 +174,12 @@ module.exports = class Query {
 
   resolver(resolver) {
     this.props.resolver = resolver;
+    this.props.context = resolver.getContext();
+    return this;
+  }
+
+  context(context) {
+    this.props.context = context;
     return this;
   }
 
@@ -175,7 +194,7 @@ module.exports = class Query {
   }
 
   cmd(cmd) {
-    this.props.cmd = cmd;
+    this.props.cmd = cmd; // Terminal cmd from QueryBuilder
     return this;
   }
 
@@ -185,14 +204,32 @@ module.exports = class Query {
     switch (method) {
       case 'createOne': case 'createMany': {
         this.props.crud = 'create';
+        this.props.key = `create${this.props.model}`;
         break;
       }
       case 'updateOne': case 'updateMany': {
         this.props.crud = 'update';
+        this.props.key = `update${this.props.model}`;
         break;
       }
-      case 'deleteOne': case 'deleteMay': case 'removeOne': case 'removeMany': {
+      case 'deleteOne': case 'deleteMany': case 'removeOne': case 'removeMany': {
         this.props.crud = 'delete';
+        this.props.key = `delete${this.props.model}`;
+        break;
+      }
+      case 'count': {
+        this.props.crud = 'read';
+        this.props.key = `count${this.props.model}`;
+        break;
+      }
+      case 'findOne': {
+        this.props.crud = 'read';
+        this.props.key = `get${this.props.model}`;
+        break;
+      }
+      case 'findMany': {
+        this.props.crud = 'read';
+        this.props.key = `find${this.props.model}`;
         break;
       }
       default: {
@@ -209,6 +246,11 @@ module.exports = class Query {
     return this;
   }
 
+  key(key) {
+    this.props.key = key;
+    return this;
+  }
+
   input(input = {}) { // Allows .save(/* empty */);
     // delete input.id; // We do not want to allow changing id via input
     this.props.input = input;
@@ -241,17 +283,20 @@ module.exports = class Query {
   }
 
   clone() {
-    return new Query({ ...this.props });
+    const clone = new Query();
+    clone.props = { ...this.props };
+    return clone;
   }
 
   toDriver() {
+    const self = this;
     const { model } = this.props;
     const isSorted = Boolean(Object.keys(this.props.$sort || {}).length);
 
     return {
       isNative: Boolean(this.props.native),
       model: model.getKey(),
-      shape: model.getShape('deserialize', false),
+      shape: model.getShape(),
       method: this.props.method,
       select: this.props.$select,
       joins: this.props.joins,
@@ -261,9 +306,22 @@ module.exports = class Query {
       skip: this.props.skip,
       limit: this.props.limit,
       first: isSorted ? this.props.first : undefined,
-      after: isSorted && this.props.after ? model.normalize(this, JSON.parse(Buffer.from(this.props.after, 'base64').toString('ascii')), 'serialize') : undefined,
       last: isSorted ? this.props.last : undefined,
-      before: isSorted && this.props.before ? model.normalize(this, JSON.parse(Buffer.from(this.props.before, 'base64').toString('ascii')), 'serialize') : undefined,
+      // before: isSorted && this.props.before ? model.normalize(this, JSON.parse(Buffer.from(this.props.before, 'base64').toString('ascii')), 'serialize') : undefined,
+      get before() {
+        if (!isSorted || !self.props.before) return undefined;
+        const shape = model.getShape('create', 'sort');
+        const before = JSON.parse(Buffer.from(self.props.before, 'base64').toString('ascii'));
+        const $before = model.shapeObject(shape, before, self);
+        return $before;
+      },
+      get after() {
+        if (!isSorted || !self.props.after) return undefined;
+        const shape = model.getShape('create', 'sort');
+        const after = JSON.parse(Buffer.from(self.props.after, 'base64').toString('ascii'));
+        const $after = model.shapeObject(shape, after, self);
+        return $after;
+      },
       options: this.props.options,
       input: this.props.$input,
       flags: this.props.flags,
@@ -278,7 +336,7 @@ module.exports = class Query {
 
   getCacheKey() {
     return {
-      // model: `${this.props.model}`,
+      cmd: this.props.cmd,
       method: this.props.method,
       where: this.props.match,
       search: this.props.search,

package/src/query/QueryBuilder.js

@@ -6,7 +6,7 @@ const { unravelObject } = require('../service/app.service');
 * QueryBuilder
 *
 * Facilitates the creation and execution of a Query. It provides a chainable API to build a query
-* plus a list of terminal commands to resolve the query.
+* plus a list of terminal commands to execute the query.
 */
 module.exports = class QueryBuilder {
   constructor(resolver, model) {
@@ -14,12 +14,13 @@ module.exports = class QueryBuilder {
 
     // Chainable commands
     this.id = (id) => { this.query.id(id); return this; };
-    this.select = (select) => { this.query.select(select); return this; };
-    this.where = (where) => { this.query.where(where); return this; };
-    this.match = (match) => { this.query.match(match); return this; };
+    this.select = (select) => { this.query.select(unravelObject(select)); return this; };
+    // this.select = (select) => { this.query.select(Object.entries(toKeyObj(select)).reduce((prev, [key, value]) => Object.assign(prev, { [key.replace(/edges.node./g, '')]: !!value }), {})); return this; };
+    this.where = (where) => { this.query.where(unravelObject(where)); return this; };
+    this.match = (match) => { this.query.match(unravelObject(match)); return this; };
     this.native = (native) => { this.query.native(native); return this; };
-    this.sort = (sort) => { this.query.sort(sort); return this; };
-    this.sortBy = (sortBy) => { this.query.sort(sortBy); return this; };
+    this.sort = (sort) => { this.query.sort(unravelObject(sort)); return this; };
+    this.sortBy = (sortBy) => { this.query.sort(unravelObject(sortBy)); return this; };
     this.limit = (limit) => { this.query.limit(limit); return this; };
     this.skip = (skip) => { this.query.skip(skip); return this; };
     this.before = (cursor) => { this.query.before(cursor); return this; };
@@ -27,64 +28,72 @@ module.exports = class QueryBuilder {
     this.meta = (meta) => { this.query.meta(meta); return this; };
     this.flags = (flags) => { this.query.flags(flags); return this; };
     this.merge = (merge) => { this.query.merge(merge); return this; };
+    this.batch = (batch) => { this.query.batch(batch); return this; };
     this.transaction = (txn) => { this.query.transaction(txn); return this; };
 
     // Terminal commands
-    this.one = (...args) => this.resolve('one', args);
-    this.many = (...args) => this.resolve('many', args);
-    this.save = (...args) => this.resolve('save', args.map(arg => unravelObject(arg)));
-    this.delete = (...args) => this.resolve('delete', args);
-    this.remove = (...args) => this.resolve('remove', args);
+    this.one = (...args) => this.execute('one', args);
+    this.many = (...args) => this.execute('many', args);
+    this.save = (...args) => this.execute('save', args.map(arg => unravelObject(arg)));
+    this.delete = (...args) => this.execute('delete', args);
+    this.remove = (...args) => this.execute('remove', args);
+    this.resolve = (...args) => this.execute('resolve', args);
     //
-    this.count = (...args) => this.resolve('count', args);
-    this.push = (...args) => this.resolve('push', args.map(arg => unravelObject(arg)));
-    this.pull = (...args) => this.resolve('pull', args.map(arg => unravelObject(arg)));
-    this.splice = (...args) => this.resolve('splice', args.map(arg => unravelObject(arg)));
-    this.first = (...args) => { this.query.first(...args); return this.resolve('first', args); };
-    this.last = (...args) => { this.query.last(...args); return this.resolve('last', args); };
+    this.count = (...args) => this.execute('count', args);
+    this.push = (...args) => this.execute('push', args.map(arg => unravelObject(arg)));
+    this.pull = (...args) => this.execute('pull', args.map(arg => unravelObject(arg)));
+    this.splice = (...args) => this.execute('splice', args.map(arg => unravelObject(arg)));
+    this.first = (...args) => { this.query.first(...args); return this.execute('first', args); };
+    this.last = (...args) => { this.query.last(...args); return this.execute('last', args); };
     //
     // this.min = (...args) => this.makeTheCall(query, 'min', args);
     // this.max = (...args) => this.makeTheCall(query, 'max', args);
     // this.avg = (...args) => this.makeTheCall(query, 'avg', args);
+    // this.sum = (...args) => this.makeTheCall(query, 'sum', args); // Would sum be different than count?
     // // Food for thought...
     // this.archive = (...args) => this.makeTheCall(query, 'archive', args); // Soft Delete
     // this.stream = (...args) => this.makeTheCall(query, 'stream', args); // Stream records 1 by 1
-    // this.sum = (...args) => this.makeTheCall(query, 'sum', args); // Would sum be different than count?
     // this.rollup = (...args) => this.makeTheCall(query, 'rollup', args); // Like sum, but for nested attributes (eg. Person.rollupAuthoredChaptersPages)
   }
 
-  resolve(cmd, args) {
-    let method, crud, input = {};
-    let { flags = {} } = this.query.toObject();
+  execute(cmd, args) {
+    let method, crud, input, flags = {};
     const { id, where } = this.query.toObject();
 
     switch (cmd) {
+      case 'resolve': {
+        crud = 'read';
+        method = 'autoResolve';
+        break;
+      }
       case 'one': case 'many': {
         crud = 'read';
-        flags = args[0] || flags;
+        [flags] = args;
         method = cmd === 'one' ? 'findOne' : 'findMany';
         break;
       }
       case 'first': case 'last': {
         crud = 'read';
-        flags = args[1] || flags;
+        [, flags] = args;
         method = cmd;
         break;
       }
       case 'save': {
+        [input, flags] = args;
         crud = id || where ? 'update' : 'create';
-        if (crud === 'update') { method = id ? 'updateOne' : 'updateMany'; [input] = args; }
-        if (crud === 'create') { method = args.length < 2 ? 'createOne' : 'createMany'; input = args.length < 2 ? args[0] || {} : args; }
+        if (crud === 'update') { method = id ? 'updateOne' : 'updateMany'; }
+        if (crud === 'create') { method = Array.isArray(input) ? 'createMany' : 'createOne'; }
         break;
       }
       case 'push': case 'pull': case 'splice': {
+        // [target, input, flags] = args;
         crud = 'update'; // Your logic wants this to be a simple "update". Sub documents systemEvents will emit either "create" or "udpate"
         method = id ? `${cmd}One` : `${cmd}Many`;
         break;
       }
       case 'remove': case 'delete': {
         crud = 'delete';
-        flags = args[0] || flags;
+        [flags] = args;
         if (id) method = 'deleteOne';
         else if (where) method = 'deleteMany';
         else return Promise.reject(new Error('Remove requires an id() or where()'));
@@ -92,7 +101,7 @@ module.exports = class QueryBuilder {
       }
       case 'count': {
         crud = 'read';
-        flags = args[0] || flags;
+        [flags] = args;
         method = 'count';
         break;
       }
@@ -101,6 +110,6 @@ module.exports = class QueryBuilder {
       }
     }
 
-    return new QueryResolver(this.query.cmd(cmd).method(method).crud(crud).input(input).flags(flags).args(args)).resolve();
+    return new QueryResolver(this.query.method(method).cmd(cmd).crud(crud).input(input).flags(flags).args(args)).resolve();
   }
 };

package/src/query/QueryBuilderTransaction.js

@@ -6,7 +6,7 @@ module.exports = class QueryBuilderTransaction extends QueryBuilder {
     this.query.transaction(transaction);
   }
 
-  resolve(cmd, args) {
+  execute(cmd, args) {
     return new Promise((resolve, reject) => {
       this.theCall = { cmd, args, resolve, reject };
     });
@@ -15,10 +15,10 @@ module.exports = class QueryBuilderTransaction extends QueryBuilder {
   exec(options) {
     if (!this.theCall) return undefined;
 
-    this.query.options(options);
     const { cmd, args, resolve } = this.theCall;
+    this.query.options(options);
 
-    return super.resolve(cmd, args).then((result) => {
+    return super.execute(cmd, args).then((result) => {
       resolve(result);
       return result;
     });

package/src/query/QueryResolver.js

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

package/src/query/QueryService.js

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