@coderich/autograph 0.9.12 → 0.9.15

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@coderich/autograph",
   "author": "Richard Livolsi (coderich)",
-  "version": "0.9.12",
+  "version": "0.9.15",
   "description": "AutoGraph",
   "keywords": [
     "graphql",
@@ -30,7 +30,6 @@
     "ratchet": "ratchet"
   },
   "dependencies": {
-    "@graphql-tools/schema": "^8.3.14",
     "@hapi/boom": "^9.1.0",
     "axios": "^0.21.4",
     "dataloader": "^2.0.0",
@@ -55,9 +54,6 @@
     "redis": "^2.8.0",
     "redis-mock": "^0.47.0"
   },
-  "peerDependencies": {
-    "graphql": ">15"
-  },
   "repository": {
     "type": "git",
     "url": "git@github.com:coderich/autograph.git"

package/src/core/Resolver.js

@@ -1,3 +1,4 @@
+const { isEmpty } = require('lodash');
 const Model = require('../data/Model');
 const Query = require('../query/Query');
 const ResultSet = require('../data/ResultSet');
@@ -89,7 +90,7 @@ module.exports = class Resolver {
         // This is needed in SF tests...
         const key = model.idKey();
         const { where, method } = query.toDriver();
-        if (Object.prototype.hasOwnProperty.call(where, key) && where[key] == null) return Promise.resolve(method === 'findMany' ? [] : null);
+        if (Object.prototype.hasOwnProperty.call(where, key) && isEmpty(where[key])) return Promise.resolve(method === 'findMany' ? [] : null);
 
         //
         return this.loaders.get(`${model}`).load(query);

package/src/data/Field.js

@@ -2,7 +2,7 @@ const Type = require('./Type');
 const Field = require('../graphql/ast/Field');
 const Rule = require('../core/Rule');
 const Transformer = require('../core/Transformer');
-const { map, uvl, isPlainObject, ensureArray, promiseChain } = require('../service/app.service');
+const { map, uvl, isPlainObject, ensureArray } = require('../service/app.service');
 
 module.exports = class extends Field {
   constructor(model, field) {
@@ -63,17 +63,6 @@ module.exports = class extends Field {
     return transformers.concat(this.type.getDeserializers());
   }
 
-  getResolvers() {
-    const resolvers = [];
-
-    Object.entries(this.getDirectiveArgs('field', {})).forEach(([key, value]) => {
-      if (!Array.isArray(value)) value = [value];
-      if (key === 'resolve') resolvers.push(...value.map(t => Transformer.getInstances()[t]));
-    });
-
-    return resolvers.concat(this.type.getResolvers());
-  }
-
   validate(query, value) {
     const modelRef = this.getModelRef();
     const rules = [...this.getRules()];
@@ -124,20 +113,6 @@ module.exports = class extends Field {
     return this.transform(query, value, 'deserialize');
   }
 
-  /**
-   * Applies any user-defined @field(resolve: [...methods]) in series
-   * This is ONLY run when resolving a value via the $<name> attribute
-   */
-  resolve(query, value) {
-    const resolvers = [...this.getResolvers()];
-
-    return promiseChain(resolvers.map(fn => (chain) => {
-      return Promise.resolve(fn(this, uvl(this.cast(chain.pop()), value), query));
-    })).then((results) => {
-      return uvl(this.cast(results.pop()), value);
-    });
-  }
-
   tform(query, value) {
     // Determine transformers
     const transformers = this.getTransformers();

package/src/data/Model.js

@@ -160,4 +160,24 @@ module.exports = class extends Model {
       }, {});
     });
   }
+
+  getShape(serdes = 'deserialize', recursive = true) {
+    return this.getSelectFields().map((field) => {
+      const [from, to] = serdes === 'serialize' ? [field.getName(), field.getKey()] : [field.getKey(), field.getName()];
+      const shape = recursive && field.isEmbedded() ? field.getModelRef().getShape(serdes, recursive) : null;
+      return { from, to, type: field.getDataType(), isArray: field.isArray(), shape };
+    });
+  }
+
+  shape(data, serdes = (() => { throw new Error('No Sir Sir SerDes!'); }), shape) {
+    shape = shape || this.getShape(serdes);
+
+    return map(data, (doc) => {
+      return shape.reduce((prev, { from, to, shape: subShape }) => {
+        const value = doc[from];
+        if (value === undefined) return prev;
+        return Object.assign(prev, { [to]: subShape ? this.shape(value, serdes, subShape) : value });
+      }, {});
+    });
+  }
 };

package/src/data/ResultSet.js

@@ -1,170 +1,51 @@
 const { get } = require('lodash');
 const DataService = require('./DataService');
-const { map, ensureArray, keyPaths, mapPromise, toGUID, hashObject } = require('../service/app.service');
+const { map, ensureArray, keyPaths, toGUID } = require('../service/app.service');
+
+const modelCache = new WeakMap();
 
 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;
+    ResultSet.ensureModelCache(model);
 
-      //
-      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,
-        },
+    const { template, fieldDefs } = modelCache.get(model);
 
-        $id: {
-          get() { return toGUID(model.getName(), this.id); },
-          enumerable: false,
-        },
+    const rs = map(data, (doc) => {
+      if (doc == null || typeof doc !== 'object') return doc;
 
-        $$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');
+      const instance = Object.create(template, {
+        $$services: {
+          value: {
+            cache: new Map(),
+            data: doc,
+            resolver,
+            query,
+            sort,
           },
           enumerable: false,
         },
+      });
 
-        $$model: {
-          value: model,
-          enumerable: false,
+      return new Proxy(instance, {
+        ownKeys(target) {
+          return Reflect.ownKeys(target).concat('id', fieldDefs.map(d => d.name));
         },
-
-        $$isResultSetItem: {
-          value: true,
-          enumerable: false,
+        getOwnPropertyDescriptor(target, prop) {
+          return (prop === 'id' || fieldDefs.find(el => el.name === prop)) ? { enumerable: true, configurable: true } : Reflect.getOwnPropertyDescriptor(target, prop);
         },
-
-        $$save: {
-          get() { return input => resolver.match(model).id(this.id).save({ ...this, ...input }); },
-          enumerable: false,
+        getPrototypeOf() {
+          return { $$services: instance.$$services };
         },
-
-        $$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,
+        deleteProperty(target, prop) {
+          const { key = prop } = fieldDefs.find(d => d.name === prop);
+          delete instance[prop];
+          delete instance.$$services.data[key];
         },
       });
-
-      // Create and return ResultSetItem
-      return Object.defineProperties({}, definition);
     });
 
     let hasNextPage = false;
@@ -202,4 +83,164 @@ module.exports = class ResultSet {
       },
     });
   }
+
+  static ensureModelCache(model) {
+    if (!modelCache.has(model)) {
+      const fields = model.getFields().filter(f => f.getName() !== 'id');
+
+      const fieldDefs = fields.map(field => ({
+        field,
+        key: field.getKey(),
+        name: field.getName(),
+        isArray: field.isArray(),
+        isScalar: field.isScalar(),
+        isVirtual: field.isVirtual(),
+        isRequired: field.isRequired(),
+        isEmbedded: field.isEmbedded(),
+        modelRef: field.getModelRef(),
+        virtualField: field.getVirtualField(),
+        // deserialize: field.deserialize.bind(field),
+        // fieldResolve: field.resolve.bind(field),
+        get useDefaultResolver() { return Boolean(this.isScalar || this.isEmbedded); },
+      }));
+
+      const template = ResultSet.makeModelTemplate(model, fieldDefs);
+
+      modelCache.set(model, { template, fieldDefs });
+    }
+  }
+
+  static makeModelTemplate(model, fieldDefs) {
+    const definition = fieldDefs.reduce((prev, fieldDef) => {
+      const { field, key, name, isArray, isVirtual, isRequired, isEmbedded, modelRef, virtualField, useDefaultResolver } = fieldDef;
+      const $name = `$${name}`;
+
+      // Deserialized field attributes
+      prev[name] = {
+        get() {
+          if (this.$$services.cache.has(name)) return this.$$services.cache.get(name);
+          let $value = field.deserialize(this.$$services.query, this.$$services.data[key]);
+          if ($value != null && isEmbedded) $value = new ResultSet(this.$$services.query.model(modelRef), $value, false);
+          this.$$services.cache.set(name, $value);
+          return $value;
+        },
+        set($value) {
+          this.$$services.cache.set(name, $value);
+        },
+        enumerable: true,
+        configurable: true, // Allows things like delete
+      };
+
+      // Fully deserialized, hydrated, and resolved field attributes
+      prev[$name] = {
+        get() {
+          return (args = {}) => {
+            // Grab deserialized value
+            const $value = this[name];
+
+            // Default resolver return immediately!
+            if (useDefaultResolver) return $value;
+
+            // Ensure where clause for DB lookup
+            args.where = args.where || {};
+
+            if (isArray) {
+              if (isVirtual) {
+                args.where[[virtualField]] = this.id; // Is where[[virtualField]] correct?
+                return this.$$services.resolver.match(modelRef).merge(args).many();
+              }
+
+              // Not a "required" query + strip out nulls
+              args.where.id = $value;
+              return this.$$services.resolver.match(modelRef).merge(args).many();
+            }
+
+            if (isVirtual) {
+              args.where[[virtualField]] = this.id;
+              return this.$$services.resolver.match(modelRef).merge(args).one();
+            }
+
+            return this.$$services.resolver.match(modelRef).id($value).one({ required: isRequired });
+          };
+        },
+        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 (isVirtual) q.where[virtualField] = this.id;
+            else q.where.id = this[name];
+            return this.$$services.resolver.match(modelRef).merge(q).count();
+          };
+        },
+        enumerable: false,
+      };
+
+      return prev;
+    }, {
+      id: {
+        get() { return this.$$services.data.id || this.$$services.data[model.idKey()]; },
+        set(id) { this.$$services.data.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(this.$$services.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 => this.$$services.resolver.match(model).id(this.id).save({ ...this, ...input }); },
+        enumerable: false,
+      },
+
+      $$remove: {
+        get() { return () => this.$$services.resolver.match(model).id(this.id).remove(); },
+        enumerable: false,
+      },
+
+      $$delete: {
+        get() { return () => this.$$services.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,
+      },
+    });
+
+    // return Object.defineProperties({}, definition);
+    return Object.create(null, definition);
+  }
 };

package/src/data/Type.js

@@ -69,18 +69,4 @@ module.exports = class extends Type {
 
     return transformers;
   }
-
-  getResolvers() {
-    const resolvers = [];
-    const scalarType = this.field.getScalarRef();
-
-    if (scalarType) {
-      Object.entries(scalarType.getDirectiveArgs('field', {})).forEach(([key, value]) => {
-        if (!Array.isArray(value)) value = [value];
-        if (key === 'resolve') resolvers.push(...value.map(t => Transformer.getInstances()[t]));
-      });
-    }
-
-    return resolvers;
-  }
 };

package/src/driver/MongoDriver.js

@@ -1,3 +1,4 @@
+const Util = require('util');
 const { get, has } = require('lodash');
 const { MongoClient, ObjectID } = require('mongodb');
 const { proxyDeep, toKeyObj, globToRegex, proxyPromise, isScalarDataType, promiseRetry } = require('../service/app.service');
@@ -25,7 +26,7 @@ module.exports = class MongoDriver {
   }
 
   query(collection, method, ...args) {
-    if (has(args[args.length - 1], 'debug')) console.log(collection, method, JSON.stringify(args));
+    if (has(args[args.length - 1], 'debug')) console.log(collection, method, Util.inspect(args, { depth: null, showHidden: false, colors: true }));
     return this.raw(collection)[method](...args);
   }
 
@@ -148,15 +149,15 @@ module.exports = class MongoDriver {
   }
 
   static getAddFields(query) {
-    const { schema, where } = query;
+    const { shape, where } = query;
 
-    return Object.entries(schema).reduce((prev, [key, { type }]) => {
-      const value = where[key];
+    return shape.reduce((prev, { from, type }) => {
+      const value = where[from];
       if (value === undefined) return prev;
       if (!isScalarDataType(type)) return prev;
       const stype = String((type === 'Float' || type === 'Int' ? 'Number' : type)).toLowerCase();
       if (String(typeof value) === `${stype}`) return prev;
-      return Object.assign(prev, { [key]: { $toString: `$${key}` } });
+      return Object.assign(prev, { [from]: { $toString: `$${from}` } });
     }, {});
   }
 

package/src/graphql/ast/SchemaDecorator.js

@@ -96,8 +96,8 @@ module.exports = class SchemaDecorator extends TypeDefApi {
    */
   decorate() {
     this.initialize();
-    this.mergeSchema(frameworkExt(this));
-    this.mergeSchema(typeExt(this));
+    this.mergeSchema(frameworkExt(this), { passive: true });
+    this.mergeSchema(typeExt(this), { passive: true });
     this.initialize();
     this.mergeSchema(apiExt(this), { passive: true });
     this.finalize();

package/src/graphql/extension/api.js

@@ -90,7 +90,7 @@ module.exports = (schema) => {
         }
 
         type ${model.getName()}SubscriptionPayloadEventData {
-          ${getGQLWhereFields(model).map(field => `${field.getName()}: ${field.getSubscriptionType()}`)}
+          ${model.getFields().filter(field => field.hasGQLScope('r')).map(field => `${field.getName()}: ${field.getSubscriptionType()}`)}
         }
 
         interface ${model.getName()}SubscriptionQuery {

package/src/graphql/extension/framework.js

@@ -49,7 +49,6 @@ module.exports = (schema) => {
         onDelete: AutoGraphOnDeleteEnum
 
         enforce: [AutoGraphEnforceEnum!] #
-        resolve: [AutoGraphTransformEnum!] # Transforms when resolving
         transform: [AutoGraphTransformEnum!] # Transforms when serialize + deserialize
         serialize: [AutoGraphTransformEnum!] # Transforms when serialize
         deserialize: [AutoGraphTransformEnum!] # Transforms when deserialize

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('deserialize', false),
       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/service/app.service.js

@@ -90,7 +90,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 = arr.map((...args) => fn(...args));
   return isArray ? results : results[0];
 };
 
@@ -266,3 +266,14 @@ 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 });
+    }, {});
+  });
+};

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

package/src/data/ResultSet3.js

@@ -1,186 +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();
-
-      const validKeys = [];
-
-      const definition = {
-        get id() { return doc.id || doc[model.idKey()]; },
-        get $id() { return toGUID(model.getName(), this.id); },
-        get $$data() { return data; },
-        get $$model() { return model; },
-        get $$isResultSetItem() { return true; },
-        get $$save() { return input => resolver.match(model).id(this.id).save({ ...this, ...input }); },
-        get $$remove() { return () => resolver.match(model).id(this.id).remove(); },
-        get $$delete() { return () => resolver.match(model).id(this.id).delete(); },
-        get $$cursor() {
-          return () => {
-            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');
-          };
-        },
-        get toObject() {
-          return () => validKeys.reduce((prev, key) => Object.assign(prev, { [key]: this[key] }), {});
-        },
-      };
-
-      fields.forEach((field) => {
-        const key = field.getKey();
-        const name = field.getName();
-        const $name = `$${name}`;
-        const value = doc[key];
-        validKeys.push(name);
-
-        // Field attributes
-        Object.assign(definition, {
-          get [name]() {
-            let $value = field.deserialize(query, value);
-            $value = $value != null && field.isEmbedded() ? new ResultSet(query.model(field.getModelRef()), $value, false) : $value;
-            return $value;
-          },
-        });
-
-        // Hydrated field attributes
-        Object.assign(definition, {
-          get [$name]() {
-            return (args = {}) => {
-              // Ensure where clause
-              args.where = args.where || {};
-
-              return 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);
-                });
-              });
-            };
-          },
-        });
-
-        // Field count (let's assume it's a Connection Type - meaning dont try with anything else)
-        Object.assign(definition, {
-          get [`${$name}:count`]() {
-            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();
-            };
-          },
-        });
-      });
-
-      // Create and return ResultSetItem
-      const idk = new Proxy(definition, {
-        get(target, prop, rec) {
-          if (cache.has(prop)) return cache.get(prop);
-          const value = Reflect.get(target, prop, rec);
-          if (typeof value === 'function') return value.bind(target);
-          cache.set(prop, value);
-          return value;
-        },
-        set(target, prop, value) {
-          cache.set(prop, value);
-          return true;
-        },
-        ownKeys() {
-          return validKeys;
-        },
-        getOwnPropertyDescriptor(target, prop) {
-          if (validKeys.indexOf(prop) === -1) {
-            return {
-              writable: true,
-              enumerable: true,
-              configurable: true,
-            };
-          }
-
-          return {
-            writable: false,
-            enumerable: false,
-            configurable: false,
-          };
-        },
-      });
-
-      // console.log(idk);
-      // // console.log(idk.toObject());
-      return idk;
-    });
-
-    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,
-      },
-    });
-  }
-};

package/src/graphql/core/Field.js

@@ -1,20 +0,0 @@
-const { Kind, visit } = require('graphql');
-const Node = require('./Node');
-
-module.exports = class Field extends Node {
-  constructor(ast) {
-    super(ast);
-    // this.fields = {};
-    // if (ast) this.appendAST(ast);
-  }
-
-  appendAST(ast) {
-    // visit(ast, {
-    //   [Kind.FIELD_DEFINITION]: (node) => {
-    //     const name = node.name.value;
-    //     if (this.fields[name]) this.fields[name].appendAST(node);
-    //     else this.fields[name] = new Field(node);
-    //   },
-    // });
-  }
-};

package/src/graphql/core/GraphQL.js

@@ -1,21 +0,0 @@
-const { graphql, execute, validate } = require('graphql');
-const Schema = require('./Schema');
-
-module.exports = class GraphQL {
-  constructor(schema) {
-    this.schema = (schema instanceof Schema ? schema : new Schema(schema)).makeExecutableSchema();
-  }
-
-  exec(source, variableValues) {
-    const { schema } = this.schema;
-    return graphql({ schema, source, variableValues, contextValue: schema.context });
-  }
-
-  execute(source, variableValues) {
-
-  }
-
-  validate(source, variableValues) {
-
-  }
-};

package/src/graphql/core/Model.js

@@ -1,23 +0,0 @@
-const { Kind, visit } = require('graphql');
-const Field = require('./Field');
-const Node = require('./Node');
-
-module.exports = class Model extends Node {
-  constructor(ast) {
-    super(ast);
-    this.fields = {};
-    if (ast) this.appendAST(ast);
-  }
-
-  appendAST(ast) {
-    visit(ast, {
-      [Kind.FIELD_DEFINITION]: (node) => {
-        const name = node.name.value;
-        if (this.fields[name]) this.fields[name].appendAST(node);
-        else this.fields[name] = new Field(node);
-      },
-    });
-
-    return this;
-  }
-};

package/src/graphql/core/Node.js

@@ -1,34 +0,0 @@
-const { Kind } = require('graphql');
-
-module.exports = class Node {
-  constructor(ast) {
-    this.ast = ast;
-  }
-
-  getKind() {
-    return this.ast.kind;
-  }
-
-  getName() {
-    return this.ast.name.value;
-  }
-
-  getValue(ast = this.ast) {
-    const { value = {} } = ast;
-
-    switch (value.kind) {
-      case Kind.NULL: return null;
-      case Kind.LIST: return value.values.map(el => this.getValue({ value: el }));
-      case Kind.OBJECT: {
-        return value.fields.reduce((prev, field) => {
-          const node = new Node(field);
-          return Object.assign(prev, { [node.getName()]: node.getValue() });
-        }, {});
-      }
-      default: {
-        if (ast.values) return ast.values.map(v => v.name.value);
-        return value.value;
-      }
-    }
-  }
-};

package/src/graphql/core/Schema.js

@@ -1,63 +0,0 @@
-const FS = require('fs');
-const Glob = require('glob');
-const Merge = require('deepmerge');
-const { Kind, parse, visit, printSchema, buildSchema } = require('graphql');
-const { makeExecutableSchema } = require('graphql-tools');
-const Model = require('./Model');
-
-const modelKinds = [Kind.OBJECT_TYPE_DEFINITION, Kind.OBJECT_TYPE_EXTENSION, Kind.INTERFACE_TYPE_DEFINITION, Kind.INTERFACE_TYPE_EXTENSION];
-
-module.exports = class Schema {
-  constructor(schema) {
-    this.models = {};
-    this.schema = { typeDefs: [], context: {}, resolvers: {}, schemaDirectives: {} };
-    if (schema) this.appendSchema(schema);
-  }
-
-  appendSchema(schema) {
-    // Normalize schema
-    if (typeof schema === 'string') schema = { typeDefs: [schema] };
-    else if (schema.typeDefs && !Array.isArray(schema.typeDefs)) schema.typeDefs = [schema.typeDefs];
-
-    // Merge schema
-    this.schema = Merge(this.schema, schema);
-
-    // Visit AST to maintain model definitions
-    if (schema.typeDefs) {
-      visit(parse(schema.typeDefs.join('\n')), {
-        enter: (node) => {
-          if (modelKinds.indexOf(node.kind) > -1) {
-            const name = node.name.value;
-            if (this.models[name]) this.models[name].appendAST(node);
-            else this.models[name] = new Model(node);
-          }
-        },
-      });
-    }
-
-    return this;
-  }
-
-  appendSchemaFromFile(file) {
-    if (file.endsWith('.js')) this.appendSchema(require(file)); // eslint-disable-line global-require,import/no-dynamic-require
-    else this.appendSchema(FS.readFileSync(file, 'utf8'));
-    return this;
-  }
-
-  appendSchemaFromDirectory(dir, options) {
-    Glob.sync(`${dir}/**/*.{js,gql,graphql}`, options).forEach(file => this.appendSchemaFromFile(file));
-    return this;
-  }
-
-  makeExecutableSchema() {
-    return makeExecutableSchema(this.schema);
-  }
-
-  printSchema() {
-    return printSchema(buildSchema(this.toString()));
-  }
-
-  toString() {
-    return this.schema.typeDefs.join('\n');
-  }
-};