@coderich/autograph 0.10.0 → 0.10.3

package/src/query/QueryBuilder.js

@@ -1,12 +1,12 @@
 const Query = require('./Query');
 const QueryResolver = require('./QueryResolver');
-const { toKeyObj, unravelObject } = require('../service/app.service');
+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,13 +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.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(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; };
@@ -28,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()'));
@@ -93,7 +101,7 @@ module.exports = class QueryBuilder {
       }
       case 'count': {
         crud = 'read';
-        flags = args[0] || flags;
+        [flags] = args;
         method = 'count';
         break;
       }
@@ -102,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,86 +1,111 @@
-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();
+  }
+
+  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();
+      }
+    }
   }
 
   findOne(query) {
-    return createSystemEvent('Query', { method: 'get', query }, () => {
+    return createSystemEvent('Query', { query }, async () => {
       return this.resolver.resolve(query);
     });
   }
 
   findMany(query) {
-    return createSystemEvent('Query', { method: 'find', query }, () => {
+    return createSystemEvent('Query', { query }, async () => {
       return this.resolver.resolve(query);
     });
   }
 
   count(query) {
-    return createSystemEvent('Query', { method: 'count', query }, () => {
+    return createSystemEvent('Query', { query }, async () => {
       return this.resolver.resolve(query);
     });
   }
 
   createOne(query) {
-    const { model, input, flags } = query.toObject();
-    model.appendDefaultFields(query, input);
-
-    return createSystemEvent('Mutation', { method: 'create', query }, async () => {
-      const $input = model.serialize(query, model.appendCreateFields(input));
-      query.$input($input);
-      if (!get(flags, 'novalidate')) await model.validate(query, $input);
-      const doc = await this.resolver.resolve(query);
-      query.doc(doc);
-      return doc;
+    const { model, input } = query.toObject();
+    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)));
     });
   }
 
   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();
+    const inputShape = model.getShape('update', 'input');
+    const docShape = model.getShape('update', 'doc');
 
     return this.resolver.match(model).match(match).one({ required: true }).then((doc) => {
-      const { input } = query.toObject();
       const merged = mergeDeep(doc, input);
 
-      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 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)));
       });
     });
   }
 
   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();
     });
   }
 
   deleteOne(query) {
-    const { model, id, flags } = query.toObject();
+    const { model, id } = 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).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);
         });
@@ -151,16 +176,27 @@ 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;
 
-    return this.resolver.match(model).match(match).flags(flags).one({ required: true }).then(async (doc) => {
-      await DataService.spliceEmbeddedArray(query, doc, key, from, to);
-
-      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));
+    // Can only splice arrays
+    const field = model.getField(key);
+    const isArray = field.isArray();
+    if (!isArray) throw Boom.badRequest(`Cannot splice field '${model}.${field}'`);
+
+    return this.resolver.match(model).match(match).one({ required: true }).then(async (doc) => {
+      const array = get(doc, key) || [];
+      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));
+
+      return createSystemEvent('Mutation', { query: query.method('updateOne').doc(doc).merged(doc) }, async () => {
+        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)));
       });
     });
   }
@@ -173,11 +209,11 @@ module.exports = class QueryResolver {
     return this.findMany(query.method('findMany'));
   }
 
-  resolve() {
+  async resolve() {
     const { model, method, flags } = this.query.toObject();
 
     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 { resolver, model, match: where = {} } = 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();
-      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)));
+    if (isVirtual) {
+      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 && !field.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 });
-    }
-
-    // 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) });
+    if (modelRef && !isEmbedded) {
+      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 });
     }
 
-    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) => {
@@ -85,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) => {
@@ -97,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': {

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');
@@ -54,6 +54,11 @@ exports.stripObjectUndefineds = obj => Object.entries(obj).reduce((prev, [key, v
 exports.pushIt = (arr, it) => arr[arr.push(it) - 1];
 exports.toKeyObj = obj => exports.keyPaths(obj).reduce((prev, path) => Object.assign(prev, { [path]: _.get(obj, path) }), {});
 
+exports.getGQLReturnType = (returnType) => {
+  const typeMap = { array: /^\[.+\].?$/, connection: /.+Connection!?$/, number: /^(Int|Float)!?$/, scalar: /.*/ };
+  return Object.entries(typeMap).find(([type, pattern]) => returnType.match(pattern))[0];
+};
+
 exports.removeUndefinedDeep = (obj) => {
   return exports.unravelObject(exports.keyPaths(obj).reduce((prev, path) => {
     const value = _.get(obj, path);
@@ -90,7 +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(el => fn(el));
+  const results = isArray ? arr.map((...args) => fn(...args)) : arr.map(el => fn(el));
   return isArray ? results : results[0];
 };
 
@@ -141,14 +146,6 @@ exports.objectContaining = (a, b) => {
   return exports.hashObject(a) === exports.hashObject(b);
 };
 
-exports.serialize = (field, value) => {
-  if (!exports.isPlainObject(value)) return value;
-  const model = field.getModelRef();
-  if (!model) return value;
-  const key = model.idKey();
-  return value[key];
-};
-
 /**
  * Transform an object with dot.notation keys into an expanded object.
  * eg. { 'user.name': 'richard' } => { user: { name: 'richard' } }
@@ -266,3 +263,63 @@ exports.proxyDeep = (obj, handler, proxyMap = new WeakMap(), path = '') => {
 
   return finalProxy;
 };
+
+exports.resolveDataObject = (obj) => {
+  return Promise.all(Object.keys(obj).map(async (key) => {
+    const value = await obj[key];
+    return { key, value };
+  })).then((results) => {
+    return results.reduce((prev, { key, value }) => {
+      return Object.assign(prev, { [key]: value });
+    }, {});
+  });
+};
+
+exports.seek = (obj, paths, hint) => {
+  // We first do a normal get
+  const value = _.get(obj, paths);
+  if (!hint || value !== undefined) return value;
+
+  // Normalize paths & hint for traversal
+  const $paths = Array.isArray(paths) ? paths : paths.split('.');
+  const $hint = exports.unravelObject(hint);
+
+  // Traverse paths and get as close to the value as possible
+  const { currentValue, pathsToGo } = $paths.reduce((prev, path, i, arr) => {
+    if (prev.currentValue === undefined) return prev;
+    if (!Object.prototype.hasOwnProperty.call(prev.currentValue, path)) return prev;
+    prev.currentValue = prev.currentValue[path];
+    prev.pathsToGo = arr.slice(i + 1);
+    return prev;
+  }, { currentValue: obj, pathsToGo: $paths });
+
+  // Only if we hit an array can we continue
+  if (!Array.isArray(currentValue)) return undefined;
+
+  // If we got to the last segment we need the hint in order to verify
+  const lastPath = Boolean(pathsToGo.length === 1);
+  const arr = lastPath ? currentValue.filter(v => exports.objectContaining(v, $hint)) : currentValue;
+
+  // We keep going, recursive, till we find the first value
+  return arr.reduce((prev, v) => prev || exports.seek(v, pathsToGo, $hint), undefined);
+};
+
+exports.deseek = (shape, obj, paths, hint) => {
+  // Normalize paths
+  const $paths = (Array.isArray(paths) ? paths : paths.split('.')).map((path) => {
+    const item = shape.find(s => s.to === path); // Deserializing from unknown to expected
+    return item ? item.from : path;
+  });
+
+  // Normalize hint
+  const $hint = Object.entries(exports.toKeyObj(hint)).reduce((prev, [key, value]) => {
+    const segments = key.split('.').map((path) => {
+      const item = shape.find(s => s.to === path); // Deserializing from unknown to expected
+      return item ? item.from : path;
+    });
+
+    return Object.assign(prev, { [segments.join('.')]: value });
+  }, {});
+
+  return exports.seek(obj, $paths, $hint);
+};