@coderich/autograph 0.9.10 → 0.10.0

package/src/query/Query.js

@@ -251,7 +251,7 @@ module.exports = class Query {
     return {
       isNative: Boolean(this.props.native),
       model: model.getKey(),
-      schema: Query.getSchema(model),
+      shape: model.getShape(),
       method: this.props.method,
       select: this.props.$select,
       joins: this.props.joins,
@@ -292,22 +292,4 @@ module.exports = class Query {
       options: this.props.options,
     };
   }
-
-  static getSchema(model, name = false) {
-    return model.getSelectFields().reduce((prev, field) => {
-      const key = name ? field.getName() : field.getKey();
-      // const modelRef = field.getModelRef();
-      // const isEmbedded = field.isEmbedded();
-
-      return Object.assign(prev, {
-        [key]: {
-          field,
-          alias: name ? field.getKey() : field.getName(),
-          type: field.getDataType(),
-          isArray: field.isArray(),
-          // schema: isEmbedded ? Query.getSchema(modelRef, name) : null,
-        },
-      });
-    }, {});
-  }
 };

package/src/query/QueryBuilder.js

@@ -1,6 +1,6 @@
 const Query = require('./Query');
 const QueryResolver = require('./QueryResolver');
-const { unravelObject } = require('../service/app.service');
+const { toKeyObj, unravelObject } = require('../service/app.service');
 
 /*
 * QueryBuilder
@@ -14,7 +14,8 @@ 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(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.native = (native) => { this.query.native(native); return this; };

package/src/query/QueryResolver.js

@@ -33,10 +33,13 @@ module.exports = class QueryResolver {
     const { model, input, flags } = query.toObject();
     model.appendDefaultFields(query, input);
 
-    return createSystemEvent('Mutation', { method: 'create', query }, () => {
+    return createSystemEvent('Mutation', { method: 'create', query }, async () => {
       const $input = model.serialize(query, model.appendCreateFields(input));
       query.$input($input);
-      return get(flags, 'novalidate') ? this.resolver.resolve(query) : model.validate(query, $input).then(() => this.resolver.resolve(query));
+      if (!get(flags, 'novalidate')) await model.validate(query, $input);
+      const doc = await this.resolver.resolve(query);
+      query.doc(doc);
+      return doc;
     });
   }
 
@@ -170,7 +173,7 @@ module.exports = class QueryResolver {
     return this.findMany(query.method('findMany'));
   }
 
-  async resolve() {
+  resolve() {
     const { model, method, flags } = this.query.toObject();
 
     return this[method](this.query).then((data) => {

package/src/service/app.service.js

@@ -69,6 +69,12 @@ exports.renameObjectKey = (obj, oldKey, newKey) => {
   }
 };
 
+exports.deleteKeys = (obj, keys) => {
+  if (Array.isArray(obj)) obj.map(item => exports.deleteKeys(item, keys));
+  else if (obj === Object(obj)) { keys.forEach(key => delete obj[key]); Object.values(obj).forEach(v => exports.deleteKeys(v, keys)); }
+  return obj;
+};
+
 exports.getDeep = (obj, path, defaultValue) => {
   const [prop, ...rest] = path.split('.');
   const normalize = data => (Array.isArray(data) ? _.flatten(data) : data);

package/src/service/decorator.service.js

@@ -1,275 +1,27 @@
-const { get, set, remove, merge } = require('lodash');
 const GraphqlFields = require('graphql-fields');
-const Boom = require('../core/Boom');
-const Query = require('../query/Query');
-const { createSystemEvent } = require('./event.service');
-const { guidToId, unrollGuid, ucFirst, getDeep, ensureArray, objectContaining } = require('./app.service');
-
-const findParentField = (name, embed, model) => {
-  const schema = model.getSchema();
-  const fieldName = ucFirst(embed.isArray() ? embed.getName().replace(/s$/, '') : embed.getName());
-  const parentModelName = name.substr(0, name.lastIndexOf(fieldName));
-  const parentModel = schema.getModel(parentModelName);
-  const field = model.getFields().find(f => f.getType() === parentModelName) || parentModel.getFields().find(f => f.getType() === model.getName());
-  if (!field) throw Boom.badData(`Unable to locate parent field: '${model.getName()} -> ${parentModelName}'`);
-  return field;
-};
-
-const findParentAndContainerCreate = (name, doc, input, model, embeds) => {
-  let parent = doc;
-
-  const container = embeds.reduce((prev, embed, i) => {
-    // If further nested; must find the correct container
-    if (i > 0) {
-      const subField = findParentField(name, embed, model);
-      prev = prev.find(el => `${el.id}` === `${input[subField]}`);
-    }
-
-    parent = prev;
-    return getDeep(prev, embed.getName());
-  }, doc);
-
-  return { parent, container };
-};
-
-const findParentAndContainerUpdate = (fieldPath, doc, id, embeds) => {
-  const data = embeds.map((embed, i, arr) => getDeep(doc, arr.slice(0, i + 1).join('.')));
-  const [tail, prev = tail, head = prev] = [data[0], data[data.length - 2], data[data.length - 1]];
-  const container = head.find(el => `${id}` === `${el.id}`);
-  const parent = head === prev ? doc : prev.find(p => p[fieldPath.split('.').pop()].find(el => `${id}` === `${el.id}`));
-  return { tail, parent, container };
-};
-
-const resolveQuery = (method, name, resolver, model, embeds = []) => {
-  const [base] = embeds;
-  const curr = embeds[embeds.length - 1];
-  const fieldPath = embeds.map(field => field.getName()).join('.');
 
+const resolveQuery = (method, name, resolver, model) => {
   return async (root, args, context, info) => {
-    const { autograph } = context;
-
-    // Embedded document handler
-    if (fieldPath.length) {
-      switch (method) {
-        case 'get': {
-          // Readjust the where clause
-          const where = get(args, 'where', {});
-          set(where, `${fieldPath}.id`, args.id);
-          set(args, 'where', where);
-
-          return resolver.query(context, base.getModel(), args, info).then(([result]) => {
-            const arr = ensureArray(getDeep(result, fieldPath, []));
-            return arr.find(el => `${el.id}` === `${args.id}`);
-          });
-        }
-        case 'find': {
-          // Readjust the where clause
-          const where = get(args, 'where', {});
-          const $where = set({}, `${fieldPath}`, where);
-          set(args, 'where', $where);
-
-          return resolver.query(context, base.getModel(), args, info).then((results) => {
-            const arr = results.map(result => ensureArray(getDeep(result, fieldPath, []))).flat();
-            return arr.filter(el => objectContaining(el, where));
-          });
-        }
-        case 'count': {
-          // Readjust the where clause
-          const where = get(args, 'where', {});
-          const $where = set({}, `${fieldPath}`, where);
-          set(args, 'where', $where);
-
-          return resolver.query(context, base.getModel(), args, info).then((results) => {
-            const arr = results.map(result => ensureArray(getDeep(result, fieldPath, []))).flat();
-            return arr.filter(el => objectContaining(el, where)).length;
-          });
-        }
-        case 'create': {
-          const field = findParentField(name, curr, model);
-          const path = fieldPath.split('.').slice(0, -1).concat('id').join('.');
-          const input = unrollGuid(autograph, model, args.input);
-          const meta = args.meta || {};
-          const id = guidToId(autograph, get(input, field.getName()));
-
-          // Get overall document
-          const where = { [path]: id };
-          const doc = await autograph.resolver.match(base.getModel()).where(where).one();
-          if (!doc) throw Boom.notFound(`${base.getModel().getName()} Not Found`);
-
-          // Get parent and container within document
-          const query = new Query({ resolver: autograph.resolver, model, input, where, meta, root: doc });
-          const { container } = findParentAndContainerCreate(name, doc, input, model, embeds);
-          model.appendDefaultFields(query, input);
-
-          return createSystemEvent('Mutation', { method: 'create', query }, async () => {
-            let $$input = ensureArray(input.$input || input);
-            $$input = await Promise.all($$input.map(el => model.appendCreateFields(el, true)));
-            container.push(...$$input);
-            const $update = { [base.getName()]: get(doc, base.getName()) };
-            return autograph.resolver.match(base.getModel()).id(doc.id).flags({ novalidate: true }).save($update).then(($doc) => {
-              return getDeep(doc, fieldPath).pop();
-            });
-          });
-        }
-        case 'update': {
-          // Get overall document
-          const id = guidToId(autograph, args.id);
-          const where = { [`${fieldPath}.id`]: id };
-          const meta = args.meta || {};
-          const input = unrollGuid(autograph, model, args.input || {});
-          const doc = await autograph.resolver.match(base.getModel()).where(where).one();
-          if (!doc) throw Boom.notFound(`${base.getModel().getName()} Not Found`);
-
-          // Get parent and container within document
-          const query = new Query({ resolver: autograph.resolver, model, input, where, meta, root: doc });
-          const { tail, container } = findParentAndContainerUpdate(fieldPath, doc, id, embeds);
-
-          return createSystemEvent('Mutation', { method: 'update', query }, async () => {
-            const $input = await model.appendUpdateFields(input);
-            merge(container, $input); // Must mutate object here
-            const $update = { [base.getName()]: tail };
-            doc[base.getName()] = tail; // Deficiency in how update works; must pass entire doc
-            return autograph.resolver.match(base.getModel()).id(doc.id).flags({ novalidate: true }).save($update).then(() => container);
-          });
-        }
-        case 'delete': {
-          const id = guidToId(autograph, args.id);
-          const where = { [`${fieldPath}.id`]: id };
-          const meta = args.meta || {};
-          const doc = await autograph.resolver.match(base.getModel()).where(where).one();
-          if (!doc) throw Boom.notFound(`${base.getModel()} Not Found`);
-
-          // Get parent and container within document
-          const query = new Query({ resolver: autograph.resolver, model, where, meta, root: doc });
-          const { tail, parent, container } = findParentAndContainerUpdate(fieldPath, doc, id, embeds);
-
-          return createSystemEvent('Mutation', { method: 'delete', query }, () => {
-            const key = fieldPath.split('.').pop();
-            remove(parent[key], el => `${el.id}` === `${id}`);
-            const $update = { [base.getName()]: tail };
-            doc[base.getName()] = tail; // Deficiency in how update works; must pass entire doc
-            return autograph.resolver.match(base.getModel()).id(doc.id).flags({ novalidate: true }).save($update).then(() => container);
-          });
-        }
-        default: {
-          return null;
-        }
-      }
-    }
+    const queryInfo = { fields: GraphqlFields(info, {}, { processArguments: true }) };
 
     switch (method) {
-      case 'get': return resolver.get(context, model, args, true, info);
+      case 'get': return resolver.get(context, model, args, true, queryInfo);
       case 'find': {
         return {
-          edges: () => resolver.query(context, model, args, info),
-          pageInfo: () => resolver.query(context, model, args, info),
-          count: () => resolver.count(context, model, args, info),
+          edges: () => resolver.query(context, model, args, queryInfo),
+          pageInfo: () => resolver.query(context, model, args, queryInfo),
+          count: () => resolver.count(context, model, args, queryInfo),
         };
       }
-      case 'count': return resolver.count(context, model, args, info);
-      case 'create': return resolver.create(context, model, args, { fields: GraphqlFields(info, {}, { processArguments: true }) });
-      case 'update': return resolver.update(context, model, args, { fields: GraphqlFields(info, {}, { processArguments: true }) });
-      case 'delete': return resolver.delete(context, model, args, { fields: GraphqlFields(info, {}, { processArguments: true }) });
+      case 'count': return resolver.count(context, model, args, queryInfo);
+      case 'create': return resolver.create(context, model, args, queryInfo);
+      case 'update': return resolver.update(context, model, args, queryInfo);
+      case 'delete': return resolver.delete(context, model, args, queryInfo);
       default: return null;
     }
   };
 };
 
-const makeEmbeddedAPI = (model, method, parent) => {
-  let gql = '';
-  const modelName = model.getName();
-  const fields = model.getEmbeddedFields().filter(field => field !== parent && field.isEmbeddedApi());
-
-  if (fields.length) {
-    fields.forEach((field) => {
-      const modelRef = field.getModelRef();
-      const fieldName = ucFirst(field.isArray() ? field.getName().replace(/s$/, '') : field.getName());
-      const name = `${modelName}${fieldName}`;
-
-      switch (method) {
-        case 'create': {
-          if (field.hasFieldScope('c')) gql += exports.makeCreateAPI(name, modelRef, field);
-          break;
-        }
-        case 'read': {
-          if (field.hasFieldScope('r')) gql += exports.makeReadAPI(name, modelRef, field);
-          break;
-        }
-        case 'update': {
-          if (field.hasFieldScope('u')) gql += exports.makeUpdateAPI(name, modelRef, field);
-          break;
-        }
-        case 'delete': {
-          if (field.hasFieldScope('d')) gql += exports.makeDeleteAPI(name, modelRef, field);
-          break;
-        }
-        default: {
-          throw new Error(`Unknown method '${method}'`);
-        }
-      }
-    });
-  }
-
-  return gql;
-};
-
-const makeEmbeddedResolver = (model, resolver, type, embeds = []) => {
-  const obj = {};
-
-  const modelName = model.getName();
-  const fields = model.getEmbeddedFields().filter(field => embeds.indexOf(field) === -1 && field.isEmbeddedApi());
-
-  fields.forEach((field) => {
-    const modelRef = field.getModelRef();
-    const fieldName = ucFirst(field.isArray() ? field.getName().replace(/s$/, '') : field.getName());
-    const name = `${modelName}${fieldName}`;
-
-    switch (type) {
-      case 'query': {
-        Object.assign(obj, exports.makeQueryResolver(name, modelRef, resolver, embeds.concat(field)));
-        break;
-      }
-      case 'mutation': {
-        Object.assign(obj, exports.makeMutationResolver(name, modelRef, resolver, embeds.concat(field)));
-        break;
-      }
-      default: {
-        throw new Error(`Unknown type '${type}'`);
-      }
-    }
-  });
-
-  return obj;
-};
-
-exports.makeInputSplice = (model, embed = false) => {
-  let gql = '';
-  const fields = model.getArrayFields().filter(field => field.hasGQLScope('c', 'u', 'd') && field.isSpliceable());
-
-  if (fields.length) {
-    gql += fields.map((field) => {
-      const embedded = field.isEmbedded() ? exports.makeInputSplice(field.getModelRef(), true) : '';
-
-      return `
-        ${embedded}
-        input ${model.getName()}${ucFirst(field.getName())}InputSplice {
-          with: ${field.getGQLType('InputWhere', { splice: true })}
-          put: ${field.getGQLType('InputUpdate', { splice: true })}
-          ${embedded.length ? `splice: ${field.getModelRef().getName()}InputSplice` : ''}
-        }
-      `;
-    }).join('\n\n');
-
-    gql += `
-      input ${model.getName()}InputSplice {
-        ${fields.map(field => `${field.getName()}: ${model.getName()}${ucFirst(field.getName())}InputSplice`)}
-      }
-    `;
-  }
-
-  return gql;
-};
-
 // APIs
 exports.makeCreateAPI = (name, model, parent) => {
   let gql = '';
@@ -279,8 +31,6 @@ exports.makeCreateAPI = (name, model, parent) => {
     gql += `create${name}(input: ${model.getName()}InputCreate! ${meta}): ${model.getName()}!`;
   }
 
-  gql += makeEmbeddedAPI(model, 'create', parent);
-
   return gql;
 };
 
@@ -303,8 +53,6 @@ exports.makeReadAPI = (name, model, parent) => {
     `;
   }
 
-  gql += makeEmbeddedAPI(model, 'read', parent);
-
   return gql;
 };
 
@@ -312,21 +60,10 @@ exports.makeUpdateAPI = (name, model, parent) => {
   let gql = '';
 
   if (model.hasGQLScope('u')) {
-    const spliceFields = model.getArrayFields().filter(field => field.hasGQLScope('c', 'u', 'd') && field.isSpliceable());
     const meta = model.getMeta() ? `meta: ${model.getMeta()}` : '';
-
-    gql += `
-      update${name}(
-        id: ID!
-        input: ${model.getName()}InputUpdate
-        # ${!spliceFields.length ? '' : `splice: ${model.getName()}InputSplice`}
-        ${meta}
-      ): ${model.getName()}!
-    `;
+    gql += `update${name}(id: ID! input: ${model.getName()}InputUpdate ${meta}): ${model.getName()}!`;
   }
 
-  gql += makeEmbeddedAPI(model, 'update', parent);
-
   return gql;
 };
 
@@ -338,8 +75,6 @@ exports.makeDeleteAPI = (name, model, parent) => {
     gql += `delete${name}(id: ID! ${meta}): ${model.getName()}!`;
   }
 
-  gql += makeEmbeddedAPI(model, 'delete', parent);
-
   return gql;
 };
 
@@ -357,25 +92,23 @@ exports.makeSubscriptionAPI = (name, model, parent) => {
 };
 
 // Resolvers
-exports.makeQueryResolver = (name, model, resolver, embeds = []) => {
+exports.makeQueryResolver = (name, model, resolver) => {
   const obj = {};
-  const [field] = embeds.slice(-1);
 
-  if ((!field || field.hasFieldScope('r')) && model.hasGQLScope('r')) {
-    obj[`get${name}`] = resolveQuery('get', name, resolver, model, embeds);
-    obj[`find${name}`] = resolveQuery('find', name, resolver, model, embeds);
+  if (model.hasGQLScope('r')) {
+    obj[`get${name}`] = resolveQuery('get', name, resolver, model);
+    obj[`find${name}`] = resolveQuery('find', name, resolver, model);
   }
 
-  return Object.assign(obj, makeEmbeddedResolver(model, resolver, 'query', embeds));
+  return obj;
 };
 
-exports.makeMutationResolver = (name, model, resolver, embeds = []) => {
+exports.makeMutationResolver = (name, model, resolver) => {
   const obj = {};
-  const [field] = embeds.slice(-1);
 
-  if ((!field || field.hasFieldScope('c')) && model.hasGQLScope('c')) obj[`create${name}`] = resolveQuery('create', name, resolver, model, embeds);
-  if ((!field || field.hasFieldScope('u')) && model.hasGQLScope('u')) obj[`update${name}`] = resolveQuery('update', name, resolver, model, embeds);
-  if ((!field || field.hasFieldScope('d')) && model.hasGQLScope('d')) obj[`delete${name}`] = resolveQuery('delete', name, resolver, model, embeds);
+  if (model.hasGQLScope('c')) obj[`create${name}`] = resolveQuery('create', name, resolver, model);
+  if (model.hasGQLScope('u')) obj[`update${name}`] = resolveQuery('update', name, resolver, model);
+  if (model.hasGQLScope('d')) obj[`delete${name}`] = resolveQuery('delete', name, resolver, model);
 
-  return Object.assign(obj, makeEmbeddedResolver(model, resolver, 'mutation', embeds));
+  return obj;
 };

package/src/service/event.service.js

@@ -56,6 +56,7 @@ exports.createSystemEvent = (name, mixed = {}, thunk = () => {}) => {
     return middleware().then(thunk);
   }).then((result) => {
     event.result = result;
+    if (event.crud === 'create') event.doc = event.query.toObject().doc;
     return systemEvent.emit('system', { type: `post${type}`, data: event }).then((postResult = result) => postResult);
   }).then((result) => {
     if (name === 'Response') return result;

package/src/service/graphql.service.js

@@ -1,7 +1,7 @@
 const { get } = require('lodash');
 const { Kind, parse, print } = require('graphql');
 const { validate } = require('graphql/validation');
-const { makeExecutableSchema } = require('graphql-tools');
+const { makeExecutableSchema } = require('@graphql-tools/schema');
 
 //
 const mergePairs = [

package/src/data/ResultSet2.js

@@ -1,210 +0,0 @@
-const { get } = require('lodash');
-const DataService = require('./DataService');
-const { map, ensureArray, keyPaths, mapPromise, toGUID, hashObject } = require('../service/app.service');
-
-module.exports = class ResultSet {
-  constructor(query, data, adjustForPagination = true) {
-    const { resolver, model, sort, first, after, last, before } = query.toObject();
-    const fields = model.getFields().filter(f => f.getName() !== 'id');
-
-    const rs = map(data, (doc) => {
-      if (doc == null || typeof doc !== 'object') return doc;
-
-      //
-      const cache = new Map();
-
-      // Base definition all results have
-      const definition = {
-        id: {
-          get() { return doc.id || doc[model.idKey()]; },
-          set(id) { doc.id = id; }, // Embedded array of documents need to set id
-          enumerable: true,
-        },
-
-        $id: {
-          get() { return toGUID(model.getName(), this.id); },
-          enumerable: false,
-        },
-
-        $$cursor: {
-          get() {
-            const sortPaths = keyPaths(sort);
-            const sortValues = sortPaths.reduce((prv, path) => Object.assign(prv, { [path]: get(this, path) }), {});
-            const sortJSON = JSON.stringify(sortValues);
-            return Buffer.from(sortJSON).toString('base64');
-          },
-          enumerable: false,
-        },
-
-        $$model: {
-          value: model,
-          enumerable: false,
-        },
-
-        $$data: {
-          value: data,
-          enumerable: false,
-        },
-
-        $$isResultSetItem: {
-          value: true,
-          enumerable: false,
-        },
-
-        $$save: {
-          get() { return input => resolver.match(model).id(this.id).save({ ...this, ...input }); },
-          enumerable: false,
-        },
-
-        $$remove: {
-          get() { return () => resolver.match(model).id(this.id).remove(); },
-          enumerable: false,
-        },
-
-        $$delete: {
-          get() { return () => resolver.match(model).id(this.id).delete(); },
-          enumerable: false,
-        },
-
-        toObject: {
-          get() {
-            return () => map(this, obj => Object.entries(obj).reduce((prev, [key, value]) => {
-              if (value === undefined) return prev;
-              prev[key] = get(value, '$$isResultSet') ? value.toObject() : value;
-              return prev;
-            }, {}));
-          },
-          enumerable: false,
-          configurable: true,
-        },
-      };
-
-      fields.forEach((field) => {
-        const key = field.getKey();
-        const name = field.getName();
-        const $name = `$${name}`;
-        const value = doc[key];
-
-        // Field attributes
-        definition[name] = {
-          get() {
-            if (cache.has(name)) return cache.get(name);
-            let $value = field.deserialize(query, value);
-            $value = $value != null && field.isEmbedded() ? new ResultSet(query.model(field.getModelRef()), $value, false) : $value;
-            cache.set(name, $value);
-            return $value;
-          },
-          set($value) {
-            cache.set(name, $value);
-          },
-          enumerable: true,
-          configurable: true, // Allows things like delete
-        };
-
-        // Hydrated field attributes
-        definition[`$${name}`] = {
-          get() {
-            return (args = {}) => {
-              // Ensure where clause
-              args.where = args.where || {};
-
-              // Cache
-              const cacheKey = `${$name}-${hashObject(args)}`;
-              if (cache.has(cacheKey)) return cache.get(cacheKey);
-
-              const promise = new Promise((resolve, reject) => {
-                (() => {
-                  const $value = this[name];
-
-                  if (field.isScalar() || field.isEmbedded()) return Promise.resolve($value);
-
-                  const modelRef = field.getModelRef();
-
-                  if (field.isArray()) {
-                    if (field.isVirtual()) {
-                      args.where[[field.getVirtualField()]] = this.id; // Is where[[field.getVirtualField()]] correct?
-                      return resolver.match(modelRef).merge(args).many();
-                    }
-
-                    // Not a "required" query + strip out nulls
-                    args.where.id = $value;
-                    return resolver.match(modelRef).merge(args).many();
-                  }
-
-                  if (field.isVirtual()) {
-                    args.where[[field.getVirtualField()]] = this.id;
-                    return resolver.match(modelRef).merge(args).one();
-                  }
-
-                  return resolver.match(modelRef).id($value).one({ required: field.isRequired() });
-                })().then((results) => {
-                  if (results == null) return field.resolve(query, results); // Allow field to determine
-                  return mapPromise(results, result => field.resolve(query, result)).then(() => results); // Resolve the inside fields but still return "results"!!!!
-                }).then((resolved) => {
-                  resolve(resolved);
-                }).catch((e) => {
-                  reject(e);
-                });
-              });
-
-              cache.set(cacheKey, promise);
-              return promise;
-            };
-          },
-          enumerable: false,
-        };
-
-        // Field count (let's assume it's a Connection Type - meaning dont try with anything else)
-        definition[`$${name}:count`] = {
-          get() {
-            return (q = {}) => {
-              q.where = q.where || {};
-              if (field.isVirtual()) q.where[field.getVirtualField()] = this.id;
-              else q.where.id = this[name];
-              return resolver.match(field.getModelRef()).merge(q).count();
-            };
-          },
-          enumerable: false,
-        };
-      });
-
-      // Create and return ResultSetItem
-      return Object.defineProperties({}, definition);
-    });
-
-    let hasNextPage = false;
-    let hasPreviousPage = false;
-    if (adjustForPagination && rs.length) (({ hasPreviousPage, hasNextPage } = DataService.paginateResultSet(rs, first, after, last, before)));
-
-    return Object.defineProperties(rs, {
-      $$pageInfo: {
-        get() {
-          const edges = ensureArray(rs);
-
-          return {
-            startCursor: get(edges, '0.$$cursor', ''),
-            endCursor: get(edges, `${edges.length - 1}.$$cursor`, ''),
-            hasPreviousPage,
-            hasNextPage,
-          };
-        },
-        enumerable: false,
-      },
-      $$isResultSet: {
-        value: true,
-        enumerable: false,
-      },
-      toObject: {
-        get() {
-          return () => map(this, doc => Object.entries(doc).reduce((prev, [key, value]) => {
-            if (value === undefined) return prev;
-            prev[key] = get(value, '$$isResultSet') ? value.toObject() : value;
-            return prev;
-          }, {}));
-        },
-        enumerable: false,
-        configurable: true,
-      },
-    });
-  }
-};