@coderich/autograph 0.8.13 → 0.9.0

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # CHANGELOG
 
+## v0.9.x
+- Subscriptions API
+- postMutation no longer mutates "doc" and adds "result"
+
 ## v0.8.x
 - Engine 14+
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@coderich/autograph",
   "author": "Richard Livolsi (coderich)",
-  "version": "0.8.13",
+  "version": "0.9.0",
   "description": "AutoGraph",
   "keywords": [
     "graphql",

package/src/core/EventEmitter.js

@@ -8,7 +8,7 @@ const { ensureArray } = require('../service/app.service');
  * If it expects more than 1 we block and wait for it to finish.
  */
 module.exports = class extends EventEmitter {
-  emit(event, data) {
+  emit(event, data, prev) {
     return Promise.all(this.rawListeners(event).map((wrapper) => {
       return new Promise((resolve, reject) => {
         const next = result => resolve(result); // If a result is passed this will bypass middleware thunk()
@@ -17,7 +17,9 @@ module.exports = class extends EventEmitter {
         if (numArgs < 2) next();
       });
     })).then((results) => {
-      return results.find(result => result !== undefined); // There can be only one (result)
+      if (event === 'preMutation') return this.emit('validate', data, results);
+      const target = event === 'validate' ? prev : results;
+      return target.find(r => r !== undefined); // There can be only one (result)
     });
   }
 

package/src/core/Resolver.js

@@ -7,14 +7,10 @@ const QueryBuilder = require('../query/QueryBuilder');
 
 module.exports = class Resolver {
   constructor(schema, context = {}) {
+    this.models = schema.getModels();
     this.schema = schema;
     this.context = context;
-    this.loader = new DataLoader();
-
-    // DataLoader Proxy Methods
-    this.clear = key => this.loader.clear(key);
-    this.clearAll = () => this.loader.clearAll();
-    this.prime = (key, value) => this.loader.prime(key, value);
+    this.loaders = this.models.reduce((prev, model) => prev.set(model, new DataLoader(this, model)), new WeakMap());
 
     //
     this.getSchema = () => this.schema;
@@ -55,15 +51,18 @@ module.exports = class Resolver {
     switch (crud) {
       case 'create': case 'update': case 'delete': {
         return model.getDriver().resolve(query.toDriver()).then((data) => {
-          this.clearAll();
+          this.clear(model);
           return new ResultSet(query, data);
         });
       }
       default: {
+        // This is needed in SF tests...
         const key = model.idKey();
         const { where } = query.toDriver();
         if (Object.prototype.hasOwnProperty.call(where, key) && where[key] == null) return Promise.resolve(null);
-        return this.loader.load(query);
+
+        //
+        return this.loaders.get(model).load(query);
       }
     }
   }
@@ -90,4 +89,15 @@ module.exports = class Resolver {
   toResultSet(model, data) {
     return new ResultSet(new Query({ model: this.toModel(model), resolver: this }), data);
   }
+
+  // DataLoader Proxy Methods
+  clear(model) {
+    this.loaders.get(this.toModel(model)).clearAll();
+    return this;
+  }
+
+  clearAll() {
+    this.models.forEach(model => this.clear(model));
+    return this;
+  }
 };

package/src/data/DataLoader.js

@@ -1,84 +1,42 @@
-// const { flatten } = require('lodash');
 const FBDataLoader = require('dataloader');
 const ResultSet = require('./ResultSet');
+const Query = require('../query/Query');
 const { hashObject } = require('../service/app.service');
 
 // let counter = 0;
 module.exports = class DataLoader extends FBDataLoader {
-  constructor() {
-    return new FBDataLoader((queries) => {
-      // const timeID = `${++counter}DataLoader(${queries.length})[${new Date().getTime()}]`;
-      // console.time(timeID);
-
-      // const queriesByModel = queries.reduce((prev, query, i) => {
-      //   const toDriver = query.toDriver();
-      //   const { model, method } = query.toObject();
-      //   const key = model.idKey();
-      //   prev[model] = (prev[model] || { query, model, key, get: {}, find: [] });
-      //   toDriver.$index = i;
-
-      //   if (method === 'findOne' && Object.prototype.hasOwnProperty.call(toDriver.where, key) && !Array.isArray(toDriver.where[key])) {
-      //     const { [key]: id, ...rest } = toDriver.where;
-      //     const hash = hashObject(rest);
-      //     prev[model].get[hash] = prev[model].get[hash] || [];
-      //     prev[model].get[hash].push(toDriver);
-      //     return prev;
-      //   }
-
-      //   prev[model].find.push(toDriver);
-      //   return prev;
-      // }, {});
-
-      // return new Promise((resolve, reject) => {
-      //   const results = [];
-
-      //   Promise.all(Object.values(queriesByModel).map(({ query, model, key, get, find }) => {
-      //     return Promise.all(flatten([
-      //       ...find.map(q => model.getDriver().resolve(q)),
-      //       ...Object.values(get).map((set) => {
-      //         const ids = [...new Set(set.map(({ where }) => where[key]))];
-      //         const toDriver = { ...set[0] };
-      //         toDriver.method = 'findMany';
-      //         toDriver.where[key] = ids;
-      //         return model.getDriver().resolve(toDriver).then(data => (typeof data === 'object' ? new ResultSet(query, data) : data));
-      //         // return model.getDriver().resolve(toDriver);
-      //       }),
-      //     ]));
-      //   })).then((resultsByModel) => {
-      //     console.timeEnd(timeID);
-      //     resultsByModel.forEach((modelResults, i) => {
-      //       const { key, get, find } = Object.values(queriesByModel)[i];
+  constructor(resolver, model) {
+    const idKey = model.idKey();
+    const driver = model.getDriver();
 
-      //       modelResults.splice(0, find.length).forEach((result, j) => (results[find[j].$index] = result));
-
-      //       Object.values(get).forEach((set) => {
-      //         const bundle = modelResults.shift();
-
-      //         set.forEach(({ where, $index }) => {
-      //           const id = where[key];
-      //           results[$index] = bundle.find(res => `${res[key]}` === `${id}`) || null;
-      //         });
-      //         // modelResults.splice(0, set.length).forEach((result, j) => (results[set[j].$index] = result));
-      //       });
+    return new FBDataLoader((queries) => {
+      // The idea is to group the "findOne by id" queries together to make 1 query instead
+      const { findOneByIdQueries, allOtherQueries } = queries.reduce((prev, query, i) => {
+        const { id, method } = query.toObject();
+        const key = method === 'findOne' && id ? 'findOneByIdQueries' : 'allOtherQueries';
+        prev[key].push({ id, query, i });
+        return prev;
+      }, { findOneByIdQueries: [], allOtherQueries: [] });
+
+      // Aggregate ids
+      const ids = Array.from(new Set(findOneByIdQueries.map(el => `${el.id}`)));
+      const batchQuery = new Query({ resolver, model, method: 'findMany', crud: 'read' });
+      const batchWhere = model.transform(batchQuery, { id: ids }, 'serialize', true);
+      const promises = [Promise.all(allOtherQueries.map(({ query, i }) => driver.resolve(query.toDriver()).then(data => ({ data, query, i }))))];
+      if (ids.length) promises.push(driver.resolve(batchQuery.where(batchWhere).toDriver()).then(results => findOneByIdQueries.map(({ query, id, i }) => ({ i, query, data: results.find(r => `${r[idKey]}` === `${id}`) || null }))));
+
+      return Promise.all(promises).then((results) => {
+        const sorted = results.flat().filter(Boolean).sort((a, b) => a.i - b.i);
+        return sorted.map(({ query, data }) => (data != null && typeof data === 'object' ? new ResultSet(query, data) : data));
+      });
 
-      //       return results;
-      //     });
+      // return Promise.all(queries.map((query) => {
+      //   return driver.resolve(query.toDriver()).then((data) => {
+      //     return (data != null && typeof data === 'object' ? new ResultSet(query, data) : data);
       //   });
-      // });
-
-      return Promise.all(queries.map((query) => {
-        const { model } = query.toObject();
-        return model.getDriver().resolve(query.toDriver()).then((data) => {
-          return (data != null && typeof data === 'object' ? new ResultSet(query, data) : data);
-        });
-      })).then((results) => {
-        // console.timeEnd(timeID);
-        // console.log(new Date().getTime());
-        return results;
-      });
+      // }));
     }, {
-      // cache: false,
-      // maxBatchSize: 50,
+      cache: true,
       cacheKeyFn: query => hashObject(query.getCacheKey()),
     });
   }

package/src/data/Field.js

@@ -137,4 +137,14 @@ module.exports = class extends Field {
       return uvl(this.cast(results.pop()), value);
     });
   }
+
+  tform(query, value) {
+    // Determine transformers
+    const transformers = this.getTransformers();
+
+    // Transform
+    return transformers.reduce((prev, transformer) => {
+      return transformer(this, prev, query);
+    }, this.cast(value));
+  }
 };

package/src/data/Model.js

@@ -115,7 +115,7 @@ module.exports = class extends Model {
     // Transform all the data
     return map(data, (doc) => {
       // We want the appendFields + those in the data, deduped
-      const fields = [...new Set(appendFields.concat(Object.keys(doc).map(k => this.getField(k))))].filter(f => f);
+      const fields = [...new Set(appendFields.concat(Object.keys(doc).map(k => this.getField(k))))].filter(Boolean);
 
       // Loop through the fields and delegate (renaming keys appropriately)
       return fields.reduce((prev, field) => {
@@ -129,7 +129,7 @@ module.exports = class extends Model {
   normalize(query, data, serdes = (() => { throw new Error('No Sir Sir SerDes!'); }), keysOnly = false) {
     // Transform all the data
     return map(data, (doc) => {
-      const fields = Object.keys(doc).map(k => this.getField(k)).filter(f => f);
+      const fields = Object.keys(doc).map(k => this.getField(k)).filter(Boolean);
 
       // Loop through the fields and delegate (renaming keys appropriately)
       return fields.reduce((prev, field) => {
@@ -150,4 +150,14 @@ module.exports = class extends Model {
       })));
     }));
   }
+
+  tform(query, data) {
+    return map(data, (doc) => {
+      return Object.keys(doc).map(k => this.getField(k)).filter(Boolean).reduce((prev, curr) => {
+        const key = curr.getName();
+        const value = doc[key];
+        return Object.assign(prev, { [key]: curr.tform(query, value) });
+      }, {});
+    });
+  }
 };

package/src/data/ResultSet.js

@@ -13,162 +13,157 @@ module.exports = class ResultSet {
       //
       const cache = new Map();
 
-      // Create and return ResultSetItem
-      return Object.defineProperties({},
-        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 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
+        };
 
-                const promise = new Promise((resolve, reject) => {
-                  (() => {
-                    const $value = this[name];
+        // Hydrated field attributes
+        prev[`$${name}`] = {
+          get() {
+            return (args = {}) => {
+              // Ensure where clause
+              args.where = args.where || {};
 
-                    if (field.isScalar() || field.isEmbedded()) return Promise.resolve($value);
+              // Cache
+              const cacheKey = `${$name}-${hashObject(args)}`;
+              if (cache.has(cacheKey)) return cache.get(cacheKey);
 
-                    const modelRef = field.getModelRef();
+              const promise = new Promise((resolve, reject) => {
+                (() => {
+                  const $value = this[name];
 
-                    if (field.isArray()) {
-                      if (field.isVirtual()) {
-                        args.where[[field.getVirtualField()]] = this.id; // Is where[[field.getVirtualField()]] correct?
-                        return resolver.match(modelRef).merge(args).many();
-                      }
+                  if (field.isScalar() || field.isEmbedded()) return Promise.resolve($value);
 
-                      // Not a "required" query + strip out nulls
-                      args.where.id = $value;
-                      return resolver.match(modelRef).merge(args).many();
-                    }
+                  const modelRef = field.getModelRef();
 
+                  if (field.isArray()) {
                     if (field.isVirtual()) {
-                      args.where[[field.getVirtualField()]] = this.id;
-                      return resolver.match(modelRef).merge(args).one();
+                      args.where[[field.getVirtualField()]] = this.id; // Is where[[field.getVirtualField()]] correct?
+                      return resolver.match(modelRef).merge(args).many();
                     }
 
-                    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);
-                  });
+                    // 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,
+              cache.set(cacheKey, promise);
+              return promise;
+            };
           },
-
-          $id: {
-            get() { return toGUID(model.getName(), this.id); },
-            enumerable: false,
+          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,
+        },
 
-          $$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,
-          },
+        $id: {
+          get() { return toGUID(model.getName(), this.id); },
+          enumerable: false,
+        },
 
-          $$model: {
-            value: model,
-            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,
+        },
 
-          $$data: {
-            value: data,
-            enumerable: false,
-          },
+        $$model: {
+          value: model,
+          enumerable: false,
+        },
 
-          $$isResultSetItem: {
-            value: true,
-            enumerable: false,
-          },
+        $$isResultSetItem: {
+          value: true,
+          enumerable: false,
+        },
 
-          $$save: {
-            get() { return input => resolver.match(model).id(this.id).save({ ...this, ...input }); },
-            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,
-          },
+        $$remove: {
+          get() { return () => resolver.match(model).id(this.id).remove(); },
+          enumerable: false,
+        },
 
-          $$delete: {
-            get() { return () => resolver.match(model).id(this.id).delete(); },
-            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,
+        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;

package/src/data/ResultSet2.js

@@ -0,0 +1,210 @@
+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

@@ -0,0 +1,186 @@
+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/ast/Node.js

@@ -265,9 +265,9 @@ module.exports = class Node {
     switch (this.nodeType) {
       case 'model': {
         if (!this.isMarkedModel()) return '';
-        return nvl(uvl(this.getDirectiveArg('model', 'gqlScope'), 'crud'), '');
+        return nvl(uvl(this.getDirectiveArg('model', 'gqlScope'), 'cruds'), '');
       }
-      case 'field': return nvl(uvl(this.getDirectiveArg('field', 'gqlScope'), 'crud'), '');
+      case 'field': return nvl(uvl(this.getDirectiveArg('field', 'gqlScope'), 'cruds'), '');
       default: return '';
     }
   }

package/src/graphql/extension/api.js

@@ -3,7 +3,7 @@ const { Kind } = require('graphql');
 const ServerResolver = require('../../core/ServerResolver');
 const { ucFirst, fromGUID } = require('../../service/app.service');
 const { findGQLModels } = require('../../service/schema.service');
-const { makeCreateAPI, makeReadAPI, makeUpdateAPI, makeDeleteAPI, makeInputSplice, makeQueryResolver, makeMutationResolver } = require('../../service/decorator.service');
+const { makeCreateAPI, makeReadAPI, makeUpdateAPI, makeDeleteAPI, makeSubscriptionAPI, makeInputSplice, makeQueryResolver, makeMutationResolver } = require('../../service/decorator.service');
 
 const interfaceKinds = [Kind.INTERFACE_TYPE_DEFINITION, Kind.INTERFACE_TYPE_EXTENSION];
 
@@ -20,6 +20,7 @@ const getGQLWhereFields = (model) => {
 module.exports = (schema) => {
   const resolver = new ServerResolver();
   const allModels = schema.getModels();
+  const entityModels = schema.getEntityModels();
   const markedModels = schema.getMarkedModels();
   const createModels = findGQLModels('c', markedModels, allModels);
   const readModels = findGQLModels('r', markedModels, allModels);
@@ -55,17 +56,43 @@ module.exports = (schema) => {
         extend ${interfaceKinds.indexOf(model.getKind()) > -1 ? 'interface' : 'type'} ${model.getName()} {
           ${model.getFields().filter(field => field.hasGQLScope('r')).map(field => `${field.getName()}${field.getExtendArgs()}: ${field.getPayloadType()}`)}
         }
+
         type ${model.getName()}Connection {
           pageInfo: PageInfo!
           edges: [${model.getName()}Edge]
           count: Int!
         }
+
         type ${model.getName()}Edge {
           node: ${model.getName()}
           cursor: String!
         }
       `),
 
+      ...entityModels.map(model => `
+        input ${model.getName()}SubscriptionInputWhere {
+          ${getGQLWhereFields(model).filter(field => field.isBasicType() || field.isEmbedded()).map(field => `${field.getName()}: ${field.getModelRef() ? `${ucFirst(field.getDataRef())}InputWhere` : 'AutoGraphMixed'}`)}
+        }
+
+        type ${model.getName()}SubscriptionPayloadEventData {
+          ${getGQLWhereFields(model).filter(field => field.isBasicType() || field.isEmbedded()).map(field => `${field.getName()}: ${field.getGQLType()}`)}
+        }
+
+        type ${model.getName()}SubscriptionPayloadEvent {
+          crud: SubscriptionCrudEnum!
+          data: ${model.getName()}SubscriptionPayloadEventData!
+        }
+
+        type ${model.getName()}SubscriptionPayload {
+          event: ${model.getName()}SubscriptionPayloadEvent
+        }
+
+        input ${model.getName()}SubscriptionInputFilter {
+          when: SubscriptionWhenEnum! = anytime
+          where: ${model.getName()}SubscriptionInputWhere! = {}
+        }
+      `),
+
       ...spliceModels.map(model => `
         #input ${model.getName()}InputSplice {
         #  with: ${model}InputWhere
@@ -82,14 +109,19 @@ module.exports = (schema) => {
 
       `type Query {
         node(id: ID!): Node
-        ${schema.getEntityModels().map(model => makeReadAPI(model.getName(), model))}
+        ${entityModels.map(model => makeReadAPI(model.getName(), model))}
       }`,
 
       `type Mutation {
         _noop: String
-        ${schema.getEntityModels().map(model => makeCreateAPI(model.getName(), model))}
-        ${schema.getEntityModels().map(model => makeUpdateAPI(model.getName(), model))}
-        ${schema.getEntityModels().map(model => makeDeleteAPI(model.getName(), model))}
+        ${entityModels.map(model => makeCreateAPI(model.getName(), model))}
+        ${entityModels.map(model => makeUpdateAPI(model.getName(), model))}
+        ${entityModels.map(model => makeDeleteAPI(model.getName(), model))}
+      }`,
+
+      `type Subscription {
+        _noop: String
+        ${entityModels.map(model => makeSubscriptionAPI(model.getName(), model))}
       }`,
     ]),
     resolvers: readModels.reduce((prev, model) => {
@@ -130,10 +162,10 @@ module.exports = (schema) => {
       });
     }, {
       Node: {
-        __resolveType: (root, args, context, info) => root.__typename || fromGUID(root.$id)[0],
+        __resolveType: (root, args, context, info) => root.__typename || fromGUID(root.$id)[0], // eslint-disable-line no-underscore-dangle
       },
 
-      Query: schema.getEntityModels().reduce((prev, model) => {
+      Query: entityModels.reduce((prev, model) => {
         return Object.assign(prev, makeQueryResolver(model.getName(), model, resolver));
       }, {
         node: (root, args, context, info) => {
@@ -144,7 +176,7 @@ module.exports = (schema) => {
         },
       }),
 
-      Mutation: schema.getEntityModels().reduce((prev, model) => {
+      Mutation: entityModels.reduce((prev, model) => {
         return Object.assign(prev, makeMutationResolver(model.getName(), model, resolver));
       }, {}),
     }),

package/src/graphql/extension/type.js

@@ -23,6 +23,8 @@ module.exports = (schema) => {
     }).concat(`
       interface Node { id: ID! }
       enum SortOrderEnum { asc desc }
+      enum SubscriptionCrudEnum { create update delete } # Not going to support "read"
+      enum SubscriptionWhenEnum { anytime preEvent postEvent }
     `),
   });
 };

package/src/query/Query.js

@@ -278,7 +278,7 @@ module.exports = class Query {
 
   getCacheKey() {
     return {
-      model: `${this.props.model}`,
+      // model: `${this.props.model}`,
       method: this.props.method,
       where: this.props.match,
       search: this.props.search,

package/src/service/decorator.service.js

@@ -343,6 +343,19 @@ exports.makeDeleteAPI = (name, model, parent) => {
   return gql;
 };
 
+exports.makeSubscriptionAPI = (name, model, parent) => {
+  let gql = '';
+
+  if (model.hasGQLScope('s')) {
+    gql += `${name} (
+      on: [SubscriptionCrudEnum!]! = [create, update, delete]
+      filter: ${name}SubscriptionInputFilter
+    ): ${name}SubscriptionPayload!`;
+  }
+
+  return gql;
+};
+
 // Resolvers
 exports.makeQueryResolver = (name, model, resolver, embeds = []) => {
   const obj = {};

package/src/service/event.service.js

@@ -19,13 +19,14 @@ exports.createSystemEvent = (name, mixed = {}, thunk = () => {}) => {
 
   if (name !== 'Setup') {
     const { method, query } = mixed;
-    const { resolver, model, meta, doc, id, input, sort, merged, native, root } = query.toObject();
+    const { resolver, model, meta, doc, id, input, sort, merged, native, root, crud } = query.toObject();
 
     event = {
       context: resolver.getContext(),
       key: `${method}${model}`,
       resolver,
       method,
+      crud,
       model,
       meta,
       id,
@@ -57,11 +58,8 @@ exports.createSystemEvent = (name, mixed = {}, thunk = () => {}) => {
     if (result !== undefined) return result; // Allowing middleware to dictate result
     return middleware().then(thunk);
   }).then((result) => {
-    event.doc = result; // You do actually need this...
-    if (name === 'Mutation') return systemEvent.emit('system', { type: 'preSave', data: event }).then(finalResult => finalResult || result);
-    return Promise.resolve(result);
-  }).then((result) => {
-    event.doc = result; // You do actually need this...
+    // event.doc = result; // You do actually need this...
+    event.result = result;
     return systemEvent.emit('system', { type: `post${type}`, data: event }).then(finalResult => finalResult || result);
   });
 };