@coderich/autograph 0.8.16 → 0.9.3

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.16",
+  "version": "0.9.3",
   "description": "AutoGraph",
   "keywords": [
     "graphql",

package/src/core/Resolver.js

@@ -7,14 +7,10 @@ const QueryBuilder = require('../query/QueryBuilder');
 
 module.exports = class Resolver {
   constructor(schema, context = {}) {
-    const models = schema.getModels();
+    this.models = schema.getModels();
     this.schema = schema;
     this.context = context;
-    this.loaders = models.reduce((prev, model) => prev.set(model, new DataLoader(this, model)), new WeakMap());
-
-    // DataLoader Proxy Methods
-    this.clear = model => this.loaders.get(model).clearAll();
-    this.clearAll = () => models.forEach(model => this.loaders.get(model).clearAll());
+    this.loaders = this.models.reduce((prev, model) => prev.set(`${model}`, new DataLoader(this, model)), new Map());
 
     //
     this.getSchema = () => this.schema;
@@ -66,7 +62,7 @@ module.exports = class Resolver {
         if (Object.prototype.hasOwnProperty.call(where, key) && where[key] == null) return Promise.resolve(null);
 
         //
-        return this.loaders.get(model).load(query);
+        return this.loaders.get(`${model}`).load(query);
       }
     }
   }
@@ -93,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(`${model}`).clearAll();
+    return this;
+  }
+
+  clearAll() {
+    this.models.forEach(model => this.clear(model));
+    return this;
+  }
 };

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,161 +13,6 @@ module.exports = class ResultSet {
       //
       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,
-      //   };
-      // });
-
       const definition = fields.reduce((prev, field) => {
         const key = field.getKey();
         const name = field.getName();
@@ -284,11 +129,6 @@ module.exports = class ResultSet {
           enumerable: false,
         },
 
-        $$data: {
-          value: data,
-          enumerable: false,
-        },
-
         $$isResultSetItem: {
           value: true,
           enumerable: 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,56 @@ 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.filter(model => model.hasGQLScope('s')).map(model => `
+        input ${model.getName()}SubscriptionInputFilter {
+          when: [SubscriptionWhenEnum!]! = [preEvent, postEvent]
+          where: ${model.getName()}SubscriptionInputWhere! = {}
+        }
+
+        input ${model.getName()}SubscriptionInputWhere {
+          ${getGQLWhereFields(model).map(field => `${field.getName()}: ${field.getModelRef() && !field.isFKReference() ? `${ucFirst(field.getDataRef())}InputWhere` : 'AutoGraphMixed'}`)}
+        }
+
+        type ${model.getName()}SubscriptionPayload {
+          event: ${model.getName()}SubscriptionPayloadEvent
+          query: ${model.getName()}SubscriptionQuery
+        }
+
+        type ${model.getName()}SubscriptionPayloadEvent {
+          crud: SubscriptionCrudEnum!
+          data: ${model.getName()}SubscriptionPayloadEventData!
+        }
+
+        type ${model.getName()}SubscriptionPayloadEventData {
+          ${getGQLWhereFields(model).map(field => `${field.getName()}: ${field.isFKReference() ? 'ID' : field.getGQLType()}`)}
+        }
+
+        interface ${model.getName()}SubscriptionQuery {
+          ${model.getFields().filter(field => field.hasGQLScope('r')).map(field => `${field.getName()}: ${field.getPayloadType()}`)}
+        }
+
+        type ${model.getName()}Create implements ${model.getName()}SubscriptionQuery {
+          ${model.getFields().filter(field => field.hasGQLScope('r')).map(field => `${field.getName()}: ${field.getPayloadType()}`)}
+        }
+
+        type ${model.getName()}Update implements ${model.getName()}SubscriptionQuery {
+          ${model.getFields().filter(field => field.hasGQLScope('r')).map(field => `${field.getName()}: ${field.getPayloadType()}`)}
+        }
+      `),
+
       ...spliceModels.map(model => `
         #input ${model.getName()}InputSplice {
         #  with: ${model}InputWhere
@@ -82,14 +122,21 @@ module.exports = (schema) => {
 
       `type Query {
         node(id: ID!): Node
-        ${schema.getEntityModels().map(model => makeReadAPI(model.getName(), model))}
+        ${entityModels.map(model => makeReadAPI(model.getName(), model))}
+        ${entityModels.map(model => makeReadAPI(`${model.getName()}Create`, model))}
+        ${entityModels.map(model => makeReadAPI(`${model.getName()}Update`, 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) => {
@@ -120,6 +167,15 @@ module.exports = (schema) => {
         });
       }, {});
 
+      if (model.isEntity() && model.hasGQLScope('s')) {
+        prev[`${model.getName()}SubscriptionQuery`] = {
+          __resolveType: root => root.__typename, // eslint-disable-line no-underscore-dangle
+          ...fieldResolvers,
+        };
+        prev[`${model.getName()}Create`] = fieldResolvers;
+        prev[`${model.getName()}Update`] = fieldResolvers;
+      }
+
       return Object.assign(prev, {
         [modelName]: fieldResolvers,
         [`${modelName}Connection`]: {
@@ -130,10 +186,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 +200,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

@@ -9,9 +9,13 @@ module.exports = (schema) => {
       const createdAt = model.getDirectiveArg('model', 'createdAt', 'createdAt');
       const updatedAt = model.getDirectiveArg('model', 'updatedAt', 'updatedAt');
 
-      if (model.getKind() === 'ObjectTypeDefinition') {
+      if (model.getKind() === 'ObjectTypeDefinition' && (id || createdAt || updatedAt)) {
+        const interfaces = [];
+        if (id) interfaces.push('Node');
+        const interfacesGQL = interfaces.length ? ' implements'.concat(' ', interfaces.join(' & ')) : '';
+
         return `
-          extend type ${modelName} ${id ? 'implements Node' : ''} {
+          extend type ${modelName}${interfacesGQL} {
             ${id ? `id: ID! @field(key: "${id}", gqlScope: r)` : ''}
             ${createdAt ? `createdAt: AutoGraphDateTime @field(key: "${createdAt}", gqlScope: r)` : ''}
             ${updatedAt ? `updatedAt: AutoGraphDateTime @field(key: "${updatedAt}", gqlScope: r)` : ''}
@@ -23,6 +27,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 { preEvent postEvent }
     `),
   });
 };

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

@@ -13,19 +13,20 @@ const systemEvent = new EventEmitter().setMaxListeners(100).on('system', async (
 
 //
 exports.createSystemEvent = (name, mixed = {}, thunk = () => {}) => {
-  let event;
-  let middleware;
+  let event = mixed;
+  let middleware = () => Promise.resolve();
   const type = ucFirst(name);
 
-  if (name !== 'Setup') {
+  if (name !== 'Setup' && name !== 'Response') {
     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,
@@ -48,17 +49,18 @@ exports.createSystemEvent = (name, mixed = {}, thunk = () => {}) => {
 
       resolve();
     });
-  } else {
-    middleware = () => Promise.resolve();
-    event = mixed;
   }
 
   return systemEvent.emit('system', { type: `pre${type}`, data: event }).then((result) => {
     if (result !== undefined) return result; // Allowing middleware to dictate result
     return middleware().then(thunk);
   }).then((result) => {
-    event.doc = result; // You do actually need this...
-    return systemEvent.emit('system', { type: `post${type}`, data: event }).then(finalResult => finalResult || result);
+    event.result = result;
+    return systemEvent.emit('system', { type: `post${type}`, data: event }).then((postResult = result) => postResult);
+  }).then((result) => {
+    if (name === 'Response') return result;
+    event.result = result;
+    return exports.createSystemEvent('Response', event, (finalResult = result) => finalResult);
   });
 };