@coderich/autograph 0.10.0 → 0.10.3

package/src/service/event.service.js

@@ -1,46 +1,32 @@
 const QueryService = require('../query/QueryService');
 const EventEmitter = require('../core/EventEmitter');
-const { ensureArray, ucFirst } = require('./app.service');
+const { ucFirst } = require('./app.service');
 
 // Event emitters
 const eventEmitter = new EventEmitter().setMaxListeners(100);
-const internalEmitter = new EventEmitter().setMaxListeners(100);
 const systemEvent = new EventEmitter().setMaxListeners(100).on('system', async (event, next) => {
   const { type, data } = event;
-  await internalEmitter.emit(type, data);
   next(await eventEmitter.emit(type, data)); // Return result from user-defined middleware
 });
 
-//
-exports.createSystemEvent = (name, mixed = {}, thunk = () => {}) => {
-  let event = mixed;
-  let middleware = () => Promise.resolve();
-  const type = ucFirst(name);
-
-  if (name !== 'Setup' && name !== 'Response') {
-    const { method, query } = mixed;
-    const { resolver, model, meta, doc, id, input, sort, merged, native, root, crud } = query.toObject();
+const makeEvent = (mixed) => {
+  const { query } = mixed;
+  const event = query.toObject();
+  event.query = query;
+  return event;
+};
 
-    event = {
-      context: resolver.getContext(),
-      key: `${method}${model}`,
-      resolver,
-      method,
-      crud,
-      model,
-      meta,
-      id,
-      input,
-      query,
-      doc,
-      merged,
-      root,
-    };
+const makeMiddleware = () => {
+  return (mixed) => {
+    const { query } = mixed;
+    const { model, native, sort, match, batch } = query.toObject();
 
-    middleware = () => new Promise(async (resolve) => {
+    return new Promise(async (resolve) => {
       if (!native) {
-        const $where = await QueryService.resolveWhereClause(query);
-        query.match(model.serialize(query, $where, true));
+        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) {
@@ -49,11 +35,23 @@ exports.createSystemEvent = (name, mixed = {}, thunk = () => {}) => {
 
       resolve();
     });
+  };
+};
+
+//
+exports.createSystemEvent = (name, mixed = {}, thunk = () => {}) => {
+  let event = mixed;
+  let middleware = () => Promise.resolve();
+  const type = ucFirst(name);
+
+  if (name !== 'Response') {
+    event = makeEvent(mixed);
+    middleware = makeMiddleware();
   }
 
-  return systemEvent.emit('system', { type: `pre${type}`, data: event }).then((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().then(thunk);
+    return middleware(mixed).then(thunk);
   }).then((result) => {
     event.result = result;
     if (event.crud === 'create') event.doc = event.query.toObject().doc;
@@ -66,44 +64,3 @@ exports.createSystemEvent = (name, mixed = {}, thunk = () => {}) => {
 };
 
 exports.eventEmitter = eventEmitter;
-exports.internalEmitter = internalEmitter;
-
-
-/**
- * Hook into the pre event only!
- *
- * Kick off system events for embedded fields
- */
-const eventHandler = (event) => {
-  const { model, input, method, doc = input, query } = event;
-
-  return Promise.all(model.getEmbeddedFields().map((field) => {
-    return new Promise((resolve, reject) => {
-      if (Object.prototype.hasOwnProperty.call(input || {}, field.getName())) {
-        let i = 0;
-        const value = input[field.getName()];
-        const values = ensureArray(value).filter(el => el != null);
-        const newModel = field.getModelRef();
-
-        if (values.length) {
-          values.forEach((val) => {
-            const clone = query.clone().model(newModel).input(val).doc(doc);
-            exports.createSystemEvent('Mutation', { method, query: clone }, () => {
-              if (++i >= values.length) resolve();
-            }).catch(e => reject(e));
-            // const newEvent = { parent: doc, key: `${method}${field}`, method, model: newModel, resolver, query: new Query(resolver, newModel, { meta }), input: val };
-            // exports.createSystemEvent('Mutation', newEvent, () => {
-            //   if (++i >= values.length) resolve();
-            // }).catch(e => reject(e));
-          });
-        } else {
-          resolve();
-        }
-      } else {
-        resolve();
-      }
-    });
-  }));
-};
-
-internalEmitter.on('preMutation', async (event, next) => eventHandler(event).then(next)); // Only preMutation!

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

@@ -54,11 +54,13 @@ exports.getSchemaData = (schema) => {
 exports.identifyOnDeletes = (models, parentModel) => {
   return models.reduce((prev, model) => {
     model.getOnDeleteFields().forEach((field) => {
-      if (`${field.getModelRef()}` === `${parentModel}`) {
+      const { modelRef, isArray } = field.toObject();
+
+      if (`${modelRef}` === `${parentModel}`) {
         if (model.isEntity()) {
-          prev.push({ model, field, isArray: field.isArray(), op: field.getOnDelete() });
+          prev.push({ model, field, isArray, op: field.getOnDelete() });
         } else {
-          prev.push(...exports.identifyOnDeletes(models, model).map(od => Object.assign(od, { fieldRef: field, isArray: field.isArray(), op: field.getOnDelete() })));
+          prev.push(...exports.identifyOnDeletes(models, model).map(od => Object.assign(od, { fieldRef: field, isArray, op: field.getOnDelete() })));
         }
       }
     });

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

package/src/core/Rule.js

@@ -1,107 +0,0 @@
-const { get } = require('lodash');
-const isEmail = require('validator/lib/isEmail');
-const Boom = require('./Boom');
-const { map, ensureArray, hashObject } = require('../service/app.service');
-
-const instances = {};
-const jsStringMethods = ['endsWith', 'includes', 'match', 'search', 'startsWith'];
-
-class Rule {
-  constructor(thunk, options = {}, name = 'Unknown') {
-    const {
-      ignoreNull = true,
-      itemize = true,
-      toError = (field, value, msg) => Boom.notAcceptable(`Rule (${name}) failed for { ${field.getModel()}.${field}: ${value} }`),
-    } = (options || {});
-
-    return Object.defineProperty((field, val, query) => {
-      return new Promise((resolve, reject) => {
-        if (ignoreNull && val == null) return resolve();
-
-        if (ignoreNull && itemize) {
-          return Promise.all(ensureArray(map(val, async (v) => {
-            const err = await thunk(field, v, query);
-            if (err) return Promise.reject(toError(field, v));
-            return Promise.resolve();
-          }))).then(v => resolve()).catch(e => reject(e));
-        }
-
-        return Promise.all([(async () => {
-          const err = await thunk(field, val, query);
-          if (err) return Promise.reject(toError(field, val));
-          return Promise.resolve();
-        })()]).then(v => resolve()).catch(e => reject(e));
-      });
-    }, 'type', { value: 'rule' });
-  }
-
-  static factory(name, thunk, options = {}) {
-    return Object.defineProperty(Rule, name, {
-      value: (...args) => Object.defineProperty(new Rule(thunk(...args), options, name), 'method', { value: name }),
-      writable: options.writable,
-      enumerable: options.enumerable,
-    })[name];
-  }
-
-  static extend(name, instance) {
-    const invalidArg = () => { throw new Error('Invalid argument; expected Rule factory instance'); };
-    const { method = invalidArg(), type = invalidArg() } = instance;
-    if (type !== 'rule' || !Rule[method]) invalidArg();
-    return (instances[name] = instance);
-  }
-
-  static getInstances() {
-    const defaultRules = Object.entries(Rule).map(([name, method]) => ({ name, instance: method() }));
-    const customRules = Object.entries(instances).map(([name, instance]) => ({ name, instance }));
-    const rules = defaultRules.concat(customRules);
-    return rules.reduce((prev, { name, instance }) => Object.assign(prev, { [name]: instance }), {});
-  }
-}
-
-// Factory methods
-jsStringMethods.forEach(name => Rule.factory(name, (...args) => (f, v) => !String(v)[name](...args)));
-
-// Ensures Foreign Key relationships
-Rule.factory('ensureId', () => (f, v, q) => {
-  const { resolver } = q.toObject();
-  return resolver.match(f.getType()).id(v).one().then(doc => Boolean(doc == null));
-});
-
-// Enforces required fields (only during create)
-Rule.factory('required', () => (f, v, q) => {
-  const { crud, input } = q.toObject();
-  return (crud === 'create' ? v == null : Object.prototype.hasOwnProperty.call(input, f.getName()) && v == null);
-}, { ignoreNull: false, enumerable: true });
-
-// A field cannot hold a reference to itself (model)
-Rule.factory('selfless', () => (f, v, q) => {
-  const { doc } = q.toObject();
-  if (`${v}` === `${get(doc, 'id')}`) throw Boom.badRequest(`${f.getModel()}.${f.getName()} cannot hold a reference to itself`);
-  return false;
-}, { enumerable: true });
-
-// Once set it cannot be changed
-Rule.factory('immutable', () => (f, v, q) => {
-  const { doc, crud } = q.toObject();
-  const path = `${f.getModel()}.${f.getName()}`;
-  const p = path.substr(path.indexOf('.') + 1);
-  const oldVal = get(doc, p);
-  if (crud === 'update' && oldVal !== undefined && v !== undefined && `${hashObject(v)}` !== `${hashObject(oldVal)}`) throw Boom.badRequest(`${path} is immutable; cannot be changed once set`);
-  return false;
-}, { enumerable: true });
-
-Rule.factory('allow', (...args) => (f, v) => args.indexOf(v) === -1);
-Rule.factory('deny', (...args) => (f, v) => args.indexOf(v) > -1);
-Rule.factory('range', (min, max) => {
-  if (min == null) min = undefined;
-  if (max == null) max = undefined;
-  return (f, v) => {
-    const num = +v; // Coerce to number if possible
-    const test = Number.isNaN(num) ? v.length : num;
-    return test < min || test > max;
-  };
-}, { itemize: false });
-Rule.factory('email', () => (f, v) => !isEmail(v), { enumerable: true });
-Rule.factory('distinct', () => (f, v) => false, { enumerable: true });
-
-module.exports = Rule;

package/src/core/SchemaDecorator.js

@@ -1,46 +0,0 @@
-const Model = require('../data/Model');
-const SchemaDecorator = require('../graphql/ast/SchemaDecorator');
-const { identifyOnDeletes } = require('../service/schema.service');
-const { createSystemEvent } = require('../service/event.service');
-
-// Export class
-module.exports = class extends SchemaDecorator {
-  constructor(schema, stores) {
-    super(schema);
-
-    // Create drivers
-    this.drivers = Object.entries(stores).reduce((prev, [key, value]) => {
-      const { Driver } = value;
-
-      return Object.assign(prev, {
-        [key]: {
-          dao: new Driver(value, this),
-          idKey: Driver.idKey,
-          idValue: Driver.idValue,
-        },
-      });
-    }, {});
-  }
-
-  setup() {
-    return createSystemEvent('Setup', this, () => {
-      const entities = this.models.filter(m => m.isEntity());
-
-      // Create model indexes
-      return Promise.all(entities.map(async (model) => {
-        const key = model.getKey();
-        const indexes = model.getIndexes();
-        const driver = model.getDriver();
-        if (driver.createCollection) await driver.createCollection(key);
-        return driver.createIndexes(key, indexes);
-      }));
-    });
-  }
-
-  initialize() {
-    super.initialize();
-    this.models = super.getModels().map(model => new Model(this, model, this.drivers[model.getDriverName()]));
-    this.models.forEach(model => model.referentialIntegrity(identifyOnDeletes(this.models, model)));
-    return this;
-  }
-};

package/src/core/Transformer.js

@@ -1,68 +0,0 @@
-const { get, set, uniqWith } = require('lodash');
-const { map, serialize, castCmp, hashObject } = require('../service/app.service');
-
-const instances = {};
-let allInstances;
-
-const jsStringMethods = [
-  'charAt', 'charCodeAt', 'codePointAt', 'concat', 'indexOf', 'lastIndexOf', 'localeCompare',
-  'normalize', 'padEnd', 'padStart', 'repeat', 'replace', 'search', 'slice', 'split', 'substr', 'substring',
-  'toLocaleLowerCase', 'toLocaleUpperCase', 'toLowerCase', 'toString', 'toUpperCase', 'trim', 'trimEnd', 'trimStart', 'raw',
-];
-
-class Transformer {
-  constructor(thunk, options = {}) {
-    const { ignoreNull = true, itemize = true } = (options || {});
-
-    return Object.defineProperty((field, val, query) => {
-      if (ignoreNull && val == null) return val;
-      if (ignoreNull && itemize) return map(val, v => thunk(field, v, query));
-      return thunk(field, val, query);
-    }, 'type', { value: 'transformer' });
-  }
-
-  static factory(name, thunk, options = {}) {
-    return Object.defineProperty(Transformer, name, {
-      value: (...args) => Object.defineProperty(new Transformer(thunk(...args), options), 'method', { value: name }),
-      writable: options.writable,
-      enumerable: options.enumerable,
-    })[name];
-  }
-
-  static extend(name, instance) {
-    const invalidArg = () => { throw new Error('Invalid argument; expected Transformer factory instance'); };
-    const { method = invalidArg(), type = invalidArg() } = instance;
-    if (type !== 'transformer' || !Transformer[method]) invalidArg();
-    return (instances[name] = instance);
-  }
-
-  static getInstances() {
-    if (allInstances) return allInstances;
-    const defaultTransformers = Object.entries(Transformer).map(([name, method]) => ({ name, instance: method() }));
-    const customTransformers = Object.entries(instances).map(([name, instance]) => ({ name, instance }));
-    const transformers = defaultTransformers.concat(customTransformers);
-    allInstances = transformers.reduce((prev, { name, instance }) => Object.assign(prev, { [name]: instance }), {});
-    return allInstances;
-  }
-}
-
-// Factory methods
-const enumerables = ['toLowerCase', 'toUpperCase', 'trim', 'trimEnd', 'trimStart', 'toString'];
-jsStringMethods.forEach(name => Transformer.factory(name, (...args) => (f, v) => String(v)[name](...args), { enumerable: enumerables.indexOf(name) > -1 }));
-Transformer.factory('toTitleCase', () => (f, v) => v.replace(/\w\S*/g, w => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()), { enumerable: true });
-Transformer.factory('toLocaleTitleCase', (...args) => (f, v) => v.replace(/\w\S*/g, w => w.charAt(0).toLocaleUpperCase(...args) + w.slice(1).toLocaleLowerCase()));
-Transformer.factory('toSentenceCase', () => (f, v) => v.charAt(0).toUpperCase() + v.slice(1), { enumerable: true });
-Transformer.factory('toLocaleSentenceCase', (...args) => (f, v) => v.charAt(0).toLocaleUpperCase(...args) + v.slice(1));
-Transformer.factory('toId', () => (f, v) => f.getModel().idValue(v), { enumerable: true });
-Transformer.factory('toArray', () => (f, v) => (Array.isArray(v) ? v : [v]), { itemize: false, enumerable: true });
-Transformer.factory('toDate', () => (f, v) => new Date(v), { enumerable: true, writable: true });
-Transformer.factory('dedupe', () => (f, a) => uniqWith(a, (b, c) => hashObject(b) === hashObject(c)), { ignoreNull: false, enumerable: true });
-Transformer.factory('dedupeBy', key => (f, a) => uniqWith(a, (b, c) => hashObject(b[key]) === hashObject(c[key])), { ignoreNull: false, enumerable: true });
-Transformer.factory('timestamp', () => (f, v) => Date.now(), { enumerable: true });
-Transformer.factory('first', () => (f, v) => (Array.isArray(v) ? v[0] : v), { enumerable: true });
-Transformer.factory('get', path => (f, v) => get(v, path), { enumerable: true });
-Transformer.factory('set', path => (f, v) => set({}, path, v), { enumerable: true });
-Transformer.factory('cast', type => (f, v) => castCmp(type, v));
-Transformer.factory('serialize', () => (f, v) => serialize(f, v));
-
-module.exports = Transformer;

package/src/data/Memoizer.js

@@ -1,39 +0,0 @@
-/**
- * Memoizer.
- *
- * Keeps a memoized cache of function call results; executing them once and reusing the result.
- *
- * @param {Object} src - the object|function to memoize
- * @param {Array} whitelist - whitelist of src methods to memoize (defaults to enumerable functions)
- */
-module.exports = class Memoizer {
-  constructor(src, whitelist = Object.keys(src).filter(k => typeof src[k] === 'function')) {
-    const cache = {};
-
-    return new Proxy(src, {
-      // This gets called when accessing properties of an object
-      get(target, prop, rec) {
-        const value = Reflect.get(target, prop, rec);
-
-        if (typeof value === 'function') {
-          if (whitelist.indexOf(prop) === -1) return value.bind(target);
-
-          return (...args) => {
-            const key = `${prop}:${JSON.stringify(args)}`;
-            cache[key] = Object.prototype.hasOwnProperty.call(cache, key) ? cache[key] : value.bind(target)(...args);
-            return cache[key];
-          };
-        }
-
-        return value;
-      },
-
-      // This gets called when src is a function
-      apply(target, thisArg, args) {
-        const key = JSON.stringify(args);
-        cache[key] = Object.prototype.hasOwnProperty.call(cache, key) ? cache[key] : target.call(thisArg, ...args);
-        return cache[key];
-      },
-    });
-  }
-};

package/src/data/ResultSet.js

@@ -1,205 +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) {
-    if (data == null) return data;
-    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();
-
-      const definition = fields.reduce((prev, field) => {
-        const key = field.getKey();
-        const name = field.getName();
-        const $name = `$${name}`;
-        const value = doc[key];
-
-        // Field attributes
-        prev[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
-        prev[`$${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)
-        prev[`$${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,
-        };
-
-        return prev;
-      }, {
-        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,
-        },
-
-        $$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,
-        },
-      });
-
-      // 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,
-      },
-    });
-  }
-};