@coderich/autograph 0.11.0 → 0.11.2

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@coderich/autograph",
   "author": "Richard Livolsi (coderich)",
-  "version": "0.11.0",
+  "version": "0.11.2",
   "description": "AutoGraph",
   "keywords": [
     "graphql",
@@ -30,26 +30,23 @@
     "ratchet": "ratchet"
   },
   "dependencies": {
+    "@coderich/util": "1.0.5",
     "@hapi/boom": "^9.1.0",
     "dataloader": "^2.0.0",
     "deepmerge": "^4.2.2",
     "fill-range": "^7.0.1",
-    "glob": "^7.1.6",
+    "glob": "^9.3.5",
     "graphql-fields": "^2.0.3",
     "lodash": "^4.17.21",
-    "mongodb": "^4.8.0",
-    "object-hash": "^2.0.1",
+    "mongodb": "4.17.0",
+    "object-hash": "^3.0.0",
     "picomatch": "^2.1.1"
   },
   "devDependencies": {
-    "@coderich/ratchet": "^1.5.7",
+    "@coderich/ratchet": "^1.5.8",
     "@graphql-tools/schema": "^9.0.1",
     "graphql": "^15.5.0",
     "mongodb-memory-server": "^8.7.2",
-    "neo4j-driver": "^4.0.0",
-    "neodb": "^3.0.0",
-    "redis": "^2.8.0",
-    "redis-mock": "^0.47.0",
     "validator": "^13.7.0"
   },
   "peerDependencies": {

package/src/core/EventEmitter.js

@@ -31,8 +31,8 @@ module.exports = class extends EventEmitter {
       const { key } = event;
 
       if (ensureArray(keys).indexOf(key) > -1) {
-        await fn(event, next);
         if (numArgs < 2) next();
+        await fn(event, next);
       } else {
         next();
       }
@@ -49,8 +49,8 @@ module.exports = class extends EventEmitter {
       const { key } = event;
 
       if (ensureArray(keys).indexOf(key) > -1) {
-        await fn(event, next);
         if (numArgs < 2) next();
+        await fn(event, next);
       } else {
         next();
       }
@@ -67,8 +67,8 @@ module.exports = class extends EventEmitter {
       const { model } = event;
 
       if (ensureArray(models).indexOf(`${model}`) > -1) {
-        await fn(event, next);
         if (numArgs < 2) next();
+        await fn(event, next);
       } else {
         next();
       }
@@ -85,8 +85,8 @@ module.exports = class extends EventEmitter {
       const { model } = event;
 
       if (ensureArray(models).indexOf(`${model}`) > -1) {
-        await fn(event, next);
         if (numArgs < 2) next();
+        await fn(event, next);
       } else {
         next();
       }

package/src/data/DataTransaction.js

@@ -1,161 +1,96 @@
-const { flatten } = require('lodash');
+const { get } = require('lodash');
 const TreeMap = require('./TreeMap');
 const QueryBuilderTransaction = require('../query/QueryBuilderTransaction');
 
+const makeMap = (resolver) => {
+  let resolve, reject;
+  const map = new TreeMap();
+  map.promise = new Promise((good, bad) => { resolve = good; reject = bad; });
+  map.resolve = resolve;
+  map.reject = reject;
+
+  map.ready = () => {
+    const elements = map.elements();
+    const notReady = elements.filter(el => !el.marker);
+    if (notReady.length) return [undefined, undefined];
+    let rollbackIndex = elements.findIndex(el => el.marker === 'rollback');
+    if (rollbackIndex === -1) rollbackIndex = Infinity;
+    return [elements.slice(0, rollbackIndex), elements.slice(rollbackIndex)];
+  };
+
+  map.perform = () => {
+    const [commits, rollbacks] = map.ready();
+
+    if (commits && rollbacks) {
+      const rollbackData = rollbacks.map(tnx => tnx.data).flat();
+      const commitData = commits.map(tnx => tnx.data).flat();
+
+      Promise.all(rollbackData.map(rbd => rbd.$rollback())).then(() => {
+        if (commits.length) resolver.clearAll();
+        Promise.all(commitData.map(cd => cd.$commit())).then(d => map.resolve(d));
+      }).catch(e => map.reject(e));
+    }
+
+    return map.promise;
+  };
+
+  return map;
+};
+
 module.exports = class DataTransaction {
   constructor(resolver, parentTxn) {
-    const txnMap = (parentTxn || {}).txnMap || (() => {
-      let resolve, reject;
-      const map = new TreeMap();
-      map.promise = new Promise((good, bad) => { resolve = good; reject = bad; });
-      map.resolve = resolve;
-      map.reject = reject;
-
-      map.ready = () => {
-        const elements = map.elements();
-        const notReady = elements.filter(el => !el.marker);
-        if (notReady.length) return [undefined, undefined];
-        let rollbackIndex = elements.findIndex(el => el.marker === 'rollback');
-        if (rollbackIndex === -1) rollbackIndex = Infinity;
-        return [elements.slice(0, rollbackIndex), elements.slice(rollbackIndex)];
-      };
-
-      map.perform = () => {
-        const [commits, rollbacks] = map.ready();
-
-        if (commits && rollbacks) {
-          const rollbackData = flatten(rollbacks.map(tnx => tnx.data));
-          const commitData = flatten(commits.map(tnx => tnx.data));
-
-          Promise.all(rollbackData.map(rbd => rbd.$rollback())).then(() => {
-            if (commits.length) resolver.clearAll();
-            Promise.all(commitData.map(cd => cd.$commit())).then(d => map.resolve(d));
-          }).catch(e => map.reject(e));
-        }
-
-        return map.promise;
-      };
-
-      return map;
-    })();
-
-    // Create txn
-    const txn = ((data, driverMap, txMap) => {
-      return {
-        get match() {
-          return (modelName) => {
-            const model = resolver.toModelMarked(modelName);
-            const driver = model.getDriver();
-            if (!driverMap.has(driver)) driverMap.set(driver, []);
-            const op = new QueryBuilderTransaction(resolver, model, this);
-            driverMap.get(driver).push(op);
-            return op;
-          };
-        },
-        get exec() {
-          return () => {
-            return Promise.all(Array.from(driverMap.entries()).map(([driver, ops]) => {
-              if (driver.getDirectives().transactions === false) {
-                return Promise.all(ops.map(op => op.exec())).then((results) => {
-                  results.$commit = () => resolver.clearAll();
-                  results.$rollback = () => resolver.clearAll();
-                  return results;
-                });
-              }
-
-              return driver.transaction(ops);
-            })).then((results) => {
-              data = results;
-              return flatten(results);
-            });
-          };
-        },
-        get run() {
-          return () => {
-            return this.exec().then((results) => {
-              if (txMap.root(this) === this) return this.commit().then(() => results);
-              this.commit();
-              return results;
-            }).catch((e) => {
-              if (txMap.root(this) === this) return this.rollback().then(() => Promise.reject(e));
-              this.rollback();
-              throw e;
-            });
-          };
-        },
-        get commit() {
-          return () => {
-            if (this.marker !== 'rollback') this.marker = 'commit';
-            return txMap.perform();
-          };
-        },
-        get rollback() {
-          return () => {
-            this.marker = 'rollback';
-            return txMap.perform();
-          };
-        },
-        get data() {
-          return data;
-        },
-        get txnMap() {
-          return txMap;
-        },
-      };
-    })([], new Map(), txnMap);
-
-    // Save txn to map
-    txnMap.add(parentTxn, txn);
-
-    // Return to caller
-    return txn;
+    this.data = [];
+    this.resolver = resolver;
+    this.driverMap = new Map();
+    this.txnMap = get(parentTxn, 'txnMap') || makeMap(resolver);
+    this.txnMap.add(parentTxn, this);
   }
 
-  // match(modelish) {
-  //   const model = this.resolver.toModelMarked(modelish);
-  //   const driver = model.getDriver();
-  //   if (!this.driverMap.has(driver)) this.driverMap.set(driver, []);
-  //   const op = new QueryBuilderTransaction(model, this.resolver, this);
-  //   this.driverMap.get(driver).push(op);
-  //   return op;
-  // }
-
-  // exec() {
-  //   return Promise.all(Array.from(this.driverMap.entries()).map(([driver, ops]) => {
-  //     if (driver.getDirectives().transactions === false) {
-  //       return Promise.all(ops.map(op => op.exec())).then((results) => {
-  //         results.$commit = () => this.resolver.clearAll();
-  //         results.$rollback = () => this.resolver.clearAll();
-  //         return results;
-  //       });
-  //     }
+  match(modelish) {
+    const model = this.resolver.toModelMarked(modelish);
+    const driver = model.getDriver();
+    if (!this.driverMap.has(driver)) this.driverMap.set(driver, []);
+    const op = new QueryBuilderTransaction(this.resolver, model, this);
+    this.driverMap.get(driver).push(op);
+    return op;
+  }
 
-  //     return driver.transaction(ops);
-  //   })).then((results) => {
-  //     this.data = results;
-  //     return flatten(results);
-  //   });
-  // }
+  exec() {
+    return Promise.all(Array.from(this.driverMap.entries()).map(([driver, ops]) => {
+      if (driver.getDirectives().transactions === false) {
+        return Promise.all(ops.map(op => op.exec())).then((results) => {
+          results.$commit = () => this.resolver.clearAll();
+          results.$rollback = () => this.resolver.clearAll();
+          return results;
+        });
+      }
+
+      return driver.transaction(ops);
+    })).then((results) => {
+      this.data = results;
+      return results.flat();
+    });
+  }
 
-  // run() {
-  //   return this.exec().then((results) => {
-  //     if (this.txMap.root(this) === this) return this.commit().then(() => results);
-  //     this.commit();
-  //     return results;
-  //   }).catch((e) => {
-  //     if (this.txMap.root(this) === this) return this.rollback().then(() => Promise.reject(e));
-  //     this.rollback();
-  //     throw e;
-  //   });
-  // }
+  run() {
+    return this.exec().then((results) => {
+      if (this.txnMap.root(this) === this) return this.commit().then(() => results);
+      this.commit();
+      return results;
+    }).catch((e) => {
+      if (this.txnMap.root(this) === this) return this.rollback().then(() => Promise.reject(e));
+      this.rollback();
+      throw e;
+    });
+  }
 
-  // commit() {
-  //   if (this.marker !== 'rollback') this.marker = 'commit';
-  //   return this.txMap.perform();
-  // }
+  commit() {
+    if (this.marker !== 'rollback') this.marker = 'commit';
+    return this.txnMap.perform();
+  }
 
-  // rollback() {
-  //   this.marker = 'rollback';
-  //   return this.txMap.perform();
-  // }
+  rollback() {
+    this.marker = 'rollback';
+    return this.txnMap.perform();
+  }
 };

package/src/data/Model.js

@@ -1,4 +1,6 @@
 const Stream = require('stream');
+const { get } = require('lodash');
+const { flatten } = require('@coderich/util');
 const Field = require('./Field');
 const Model = require('../graphql/ast/Model');
 const { eventEmitter } = require('../service/event.service');
@@ -129,13 +131,14 @@ module.exports = class extends Model {
     shape.model = this;
     shape.serdes = serdes;
     shape.target = target;
+    // console.log(shape.modelRef);
 
     // Cache and return
     this.shapesCache.set(cacheKey, shape);
     return shape;
   }
 
-  shapeObject(shape, obj, query, root) {
+  shapeObject(shape, obj, query, root, base, toFlat = false) {
     const { serdes, model } = shape;
     const { context, resolver, doc = {}, flags = {} } = query.toObject();
     const { pipeline } = flags;
@@ -143,8 +146,11 @@ module.exports = class extends Model {
     if (!pipeline) return obj;
     // const filters = pipeline === true ? [] : Object.entries(pipeline).map(([k, v]) => (v === false ? k : null)).filter(Boolean);
 
+    // base is the base model
+    base = base || model;
+
     return map(obj, (parent) => {
-      // "root" is the base of the object
+      // root is the base data object
       root = root || parent;
 
       // Lookup helper functions
@@ -158,7 +164,7 @@ module.exports = class extends Model {
 
         // Transform value
         const transformedValue = transformers.reduce((value, t) => {
-          const v = t({ model, field, path, docPath, rootPath, parentPath, startValue, value, resolver, context });
+          const v = t({ base, model, field, path, docPath, rootPath, parentPath, startValue, value, resolver, context });
           return v === undefined ? value : v;
         }, startValue);
 
@@ -167,22 +173,31 @@ module.exports = class extends Model {
         if (!instructed && subShape && typeof transformedValue !== 'object') return prev;
 
         // Rename key & assign value
-        prev[to] = (!subShape || transformedValue == null) ? transformedValue : this.shapeObject(subShape, transformedValue, query, root);
+        prev[to] = (!subShape || transformedValue == null) ? transformedValue : this.shapeObject(subShape, transformedValue, query, root, base, toFlat);
+
+        if (toFlat && get(doc, to) && field.getModelRef()) {
+          const val = prev[to];
+          delete prev[to];
+          Object.assign(prev, flatten({ [to]: val }, { safe: true, depth: 1 }));
+        }
 
         return prev;
       }, {});
     });
   }
 
-  validateObject(shape, obj, query, root, silent = false) {
+  validateObject(shape, obj, query, root, base, silent = false) {
     const { model } = shape;
     const { context, resolver, doc = {}, flags = {} } = query.toObject();
     const { validate = true } = flags;
 
     if (!validate) return Promise.resolve();
 
+    // base is the base model
+    base = base || model;
+
     return mapPromise(obj, (parent) => {
-      // "root" is the base of the object
+      // root is the base data object
       root = root || parent;
 
       // Lookup helper functions
@@ -195,10 +210,10 @@ module.exports = class extends Model {
 
         return Promise.all(validators.map((v) => {
           return new Promise((resolve, reject) => {
-            return Promise.resolve(v({ model, field, path, docPath, rootPath, parentPath, startValue: value, value, resolver, context })).then(resolve).catch(reject);
+            return Promise.resolve(v({ base, model, field, path, docPath, rootPath, parentPath, startValue: value, value, resolver, context })).then(resolve).catch(reject);
           });
         })).then(() => {
-          return subShape ? this.validateObject(subShape, value, query, root, true) : Promise.resolve();
+          return subShape ? this.validateObject(subShape, value, query, root, base, true) : Promise.resolve();
         });
       }));
     }).then(() => {

package/src/data/Pipeline.js

@@ -42,22 +42,6 @@ module.exports = class Pipeline {
     return Object.defineProperty(Pipeline, name, { value: (...args) => Object.defineProperty(thunk(...args), 'options', { value: options }) })[name];
   }
 
-  // static wrapper(name, factory, { ignoreNull, itemize }) {
-  //   return Object.defineProperty((args) => {
-  //     if (ignoreNull && args.value == null) return args.value;
-
-  //     if (ignoreNull && itemize) {
-  //       return map(args.value, (val, index) => {
-  //         const v = factory({ ...args, value: val, index });
-  //         return v === undefined ? val : v;
-  //       });
-  //     }
-
-  //     const val = factory(args);
-  //     return val === undefined ? args.value : val;
-  //   }, 'name', { value: name });
-  // }
-
   static createPresets() {
     // Built-In Javascript String Transformers
     const jsStringTransformers = ['toLowerCase', 'toUpperCase', 'toString', 'trim', 'trimEnd', 'trimStart'];
@@ -76,12 +60,13 @@ module.exports = class Pipeline {
     Pipeline.define('idField', ({ model, field, value }) => field.getIdModel().idValue(value.id || value));
     Pipeline.define('ensureArrayValue', ({ field, value }) => (field.toObject().isArray && !Array.isArray(value) ? [value] : value), { itemize: false });
 
-    Pipeline.define('ensureId', ({ resolver, field, value }) => {
+    Pipeline.define('ensureId', ({ resolver, model, field, value }) => {
+      const path = `${model}.${field}`;
       const { type } = field.toObject();
       const ids = Array.from(new Set(ensureArray(value).map(v => `${v}`)));
 
       return resolver.match(type).where({ id: ids }).count().then((count) => {
-        if (count !== ids.length) throw Boom.notFound(`${type} Not Found`);
+        if (count !== ids.length) throw Boom.notFound(`${type} Not Found`, { path });
       });
     }, { itemize: false });
 
@@ -124,29 +109,34 @@ module.exports = class Pipeline {
 
     // Required fields
     Pipeline.define('required', ({ model, field, value }) => {
-      if (value == null) throw Boom.badRequest(`${model}.${field} is required`);
+      const path = `${model}.${field}`;
+      if (value == null) throw Boom.badRequest(`${path} is required`, { path });
     }, { ignoreNull: false });
 
     // A field cannot hold a reference to itself
     Pipeline.define('selfless', ({ model, field, parent, parentPath, value }) => {
-      if (`${value}` === `${parentPath('id')}`) throw Boom.badRequest(`${model}.${field} cannot hold a reference to itself`);
+      const path = `${model}.${field}`;
+      if (`${value}` === `${parentPath('id')}`) throw Boom.badData(`${path} cannot hold a reference to itself`, { path });
     });
 
     // Once set it cannot be changed
     Pipeline.define('immutable', ({ model, field, docPath, parentPath, path, value }) => {
+      const $path = `${model}.${field}`;
       const hint = { id: parentPath('id') };
       const oldVal = docPath(path, hint);
-      if (oldVal !== undefined && value !== undefined && `${hashObject(oldVal)}` !== `${hashObject(value)}`) throw Boom.badRequest(`${model}.${field} is immutable; cannot be changed once set ${oldVal} -> ${value}`);
+      if (oldVal !== undefined && value !== undefined && `${hashObject(oldVal)}` !== `${hashObject(value)}`) throw Boom.badData(`${$path} is immutable; cannot be changed once set ${oldVal} -> ${value}`, { path: $path });
     });
 
     // List of allowed values
     Pipeline.factory('Allow', (...args) => function allow({ model, field, value }) {
-      if (args.indexOf(value) === -1) throw Boom.badRequest(`${model}.${field} allows ${args}; found '${value}'`);
+      const path = `${model}.${field}`;
+      if (args.indexOf(value) === -1) throw Boom.badData(`${path} allows ${args}; found '${value}'`, { path });
     });
 
     // List of disallowed values
     Pipeline.factory('Deny', (...args) => function deny({ model, field, value }) {
-      if (args.indexOf(value) > -1) throw Boom.badRequest(`${model}.${field} denys ${args}; found '${value}'`);
+      const path = `${model}.${field}`;
+      if (args.indexOf(value) > -1) throw Boom.badData(`${path} denys ${args}; found '${value}'`, { path });
     });
 
     // Min/Max range
@@ -155,9 +145,10 @@ module.exports = class Pipeline {
       if (max == null) max = undefined;
 
       return function range({ model, field, value }) {
+        const path = `${model}.${field}`;
         const num = +value; // Coerce to number if possible
         const test = Number.isNaN(num) ? value.length : num;
-        if (test < min || test > max) throw Boom.badRequest(`${model}.${field} must satisfy range ${min}:${max}; found '${value}'`);
+        if (test < min || test > max) throw Boom.badData(`${path} must satisfy range ${min}:${max}; found '${value}'`, { path });
       };
     }, { itemize: false });
   }

package/src/data/Type.js

@@ -30,7 +30,7 @@ module.exports = class extends Type {
     structures.defaultValue = Pipeline.defaultValue;
     structures.ensureArrayValue = Pipeline.ensureArrayValue;
 
-    if (enumType) structures.validators.push(Pipeline.define(`allow:${type}`, Pipeline.Allow(...enumType.getValue()), { configurable: true }));
+    if (enumType) structures.validators.push(Pipeline.define(`allow${type}`, Pipeline.Allow(...enumType.getValue()), { configurable: true }));
     if (!scalarType) return structures;
 
     return Object.entries(scalarType.getDirectiveArgs('field', {})).reduce((prev, [key, value]) => {

package/src/driver/MongoDriver.js

@@ -1,11 +1,13 @@
 const Util = require('util');
 const { get } = require('lodash');
+const { unflatten } = require('@coderich/util');
 const { MongoClient, ObjectId } = require('mongodb');
 const { map, ensureArray, proxyDeep, toKeyObj, globToRegex, proxyPromise, isScalarDataType, promiseRetry } = require('../service/app.service');
 
 module.exports = class MongoDriver {
   constructor(config) {
     this.config = config;
+    this.config.query = this.config.query || {};
     this.connection = this.connect();
     this.getDirectives = () => get(config, 'directives', {});
   }
@@ -27,7 +29,7 @@ module.exports = class MongoDriver {
   query(collection, method, ...args) {
     if (get(args[args.length - 1], 'debug') === true) console.log(collection, method, Util.inspect(args, { depth: null, showHidden: false, colors: true }));
     if (method === 'aggregate') args.splice(2);
-    return this.raw(collection)[method](...args);
+    return this.raw(collection)[method](args[0], args[1]);
   }
 
   resolve(query) {
@@ -48,15 +50,15 @@ module.exports = class MongoDriver {
 
   findMany(query) {
     const { model, options = {}, flags } = query;
-    Object.assign(options, this.config.query || {});
-    return this.query(model, 'aggregate', MongoDriver.aggregateQuery(query), options, flags).then(cursor => cursor.stream());
+    const $options = { ...this.config.query, ...options };
+    return this.query(model, 'aggregate', MongoDriver.aggregateQuery(query), $options, flags).then(cursor => cursor.stream());
   }
 
   count(query) {
     const { model, options = {}, flags } = query;
-    Object.assign(options, this.config.query || {});
+    const $options = { ...this.config.query, ...options };
 
-    return this.query(model, 'aggregate', MongoDriver.aggregateQuery(query, true), options, flags).then((cursor) => {
+    return this.query(model, 'aggregate', MongoDriver.aggregateQuery(query, true), $options, flags).then((cursor) => {
       return cursor.next().then((doc) => {
         return doc ? doc.count : 0;
       });
@@ -70,7 +72,7 @@ module.exports = class MongoDriver {
 
   updateOne({ model, where, $doc, options, flags }) {
     const $update = { $set: $doc };
-    return this.query(model, 'updateOne', where, $update, options, flags).then(() => $doc);
+    return this.query(model, 'updateOne', where, $update, options, flags).then(() => unflatten($doc, { safe: true }));
   }
 
   deleteOne({ model, where, options, flags }) {
@@ -97,25 +99,23 @@ module.exports = class MongoDriver {
   }
 
   transaction(ops) {
-    const promise = async () => {
+    return promiseRetry(() => {
       // Create session and start transaction
-      const session = await this.connection.then(client => client.startSession({ readPreference: { mode: 'primary' } }));
-      session.startTransaction({ readConcern: { level: 'snapshot' }, writeConcern: { w: 'majority' } });
-      const close = () => { session.endSession(); };
-
-      // Execute each operation with session
-      return Promise.all(ops.map(op => op.exec({ session }))).then((results) => {
-        results.$commit = () => session.commitTransaction().then(close);
-        results.$rollback = () => session.abortTransaction().then(close);
-        return results;
-      }).catch((e) => {
-        close();
-        throw e;
+      return this.connection.then(client => client.startSession({ readPreference: { mode: 'primary' } })).then((session) => {
+        session.startTransaction({ readConcern: { level: 'snapshot' }, writeConcern: { w: 'majority' } });
+        const close = () => { session.endSession(); };
+
+        // Execute each operation with session
+        return Promise.all(ops.map(op => op.exec({ session }))).then((results) => {
+          results.$commit = () => session.commitTransaction().then(close);
+          results.$rollback = () => session.abortTransaction().then(close);
+          return results;
+        }).catch((e) => {
+          close();
+          throw e;
+        });
       });
-    };
-
-    // Retry promise conditionally
-    return promiseRetry(promise, 200, 5, e => e.errorLabels && e.errorLabels.indexOf('TransientTransactionError') > -1);
+    }, 200, 5, e => e.errorLabels && e.errorLabels.indexOf('TransientTransactionError') > -1);
   }
 
   static idKey() {

package/src/graphql/ast/Schema.js

@@ -70,18 +70,14 @@ module.exports = class Schema extends TypeDefApi {
    * Asynchronously load files from a given glob pattern and merge each schema
    */
   mergeSchemaFromFiles(globPattern, options) {
-    return new Promise((resolve, reject) => {
-      Glob(globPattern, options, (err, files) => {
-        if (err) return reject(err);
-
-        return Promise.all(files.map((file) => {
-          return new Promise((res) => {
-            if (file.endsWith('.js')) res(require(file)); // eslint-disable-line global-require,import/no-dynamic-require
-            else res(FS.readFileSync(file, 'utf8'));
-          }).then(schema => this.mergeSchema(schema, options));
-        })).then(() => resolve(this)).catch(e => reject(e));
-      });
-    });
+    return Glob(globPattern, options).then((files) => {
+      return Promise.all(files.map((file) => {
+        return new Promise((res) => {
+          if (file.endsWith('.js')) res(require(file)); // eslint-disable-line global-require,import/no-dynamic-require
+          else res(FS.readFileSync(file, 'utf8'));
+        }).then(schema => this.mergeSchema(schema, options));
+      }));
+    }).then(() => this);
   }
 
   /**
@@ -128,6 +124,6 @@ module.exports = class Schema extends TypeDefApi {
   }
 
   toString() {
-    return print(this.typeDefs);
+    return print(this.schema.typeDefs);
   }
 };

package/src/graphql/extension/api.js

@@ -9,7 +9,7 @@ const interfaceKinds = [Kind.INTERFACE_TYPE_DEFINITION, Kind.INTERFACE_TYPE_EXTE
 
 const getGQLWhereFields = (model) => {
   return model.getFields().filter((field) => {
-    if (!field.hasGQLScope('r')) return false;
+    if (!field.isPersistable() || !field.hasGQLScope('r')) return false;
     const modelRef = field.getModelRef();
     if (modelRef && !modelRef.isEmbedded() && !modelRef.isEntity()) return false;
     return true;
@@ -107,8 +107,6 @@ module.exports = (schema) => {
       `type Query {
         node(id: ID!): Node
         ${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 {

package/src/graphql/extension/framework.js

@@ -8,7 +8,6 @@ module.exports = (schema) => {
       scalar AutoGraphMixed
       scalar AutoGraphDriver
       scalar AutoGraphDateTime @field(transform: toDate)
-      enum AutoGraphSchemaEnum { ${schema.getModels().map(m => m.getName()).join(' ')} }
       enum AutoGraphPipelineEnum { ${Object.keys(Pipeline).join(' ')} }
       enum AutoGraphAuthzEnum { private protected public }
       enum AutoGraphOnDeleteEnum { cascade nullify restrict defer }
@@ -28,6 +27,12 @@ module.exports = (schema) => {
         fieldScope: AutoGraphMixed # Dictate how a FIELD may use me
         authz: AutoGraphAuthzEnum # Access level used for authorization (default: private)
         namespace: String # Logical grouping of models that can be globbed (useful for authz)
+
+        # FOR TRANSITION TO NEW VERSION
+        crud: AutoGraphMixed # CRUD API
+        scope: AutoGraphMixed #
+        source: AutoGraphMixed # Data source (default: "default")
+        decorate: AutoGraphMixed # Decorator (default: "default")
       ) on OBJECT | INTERFACE
 
       directive @field(
@@ -54,6 +59,10 @@ module.exports = (schema) => {
         transform: [AutoGraphPipelineEnum!]
         serialize: [AutoGraphPipelineEnum!]
         deserialize: [AutoGraphPipelineEnum!]
+
+        # FOR TRANSITION TO NEW VERSION
+        crud: AutoGraphMixed # CRUD API
+        finalize: [AutoGraphPipelineEnum!]
       ) on FIELD_DEFINITION | INPUT_FIELD_DEFINITION | SCALAR
 
       directive @link(

package/src/query/Query.js

@@ -1,5 +1,3 @@
-const Boom = require('../core/Boom');
-
 module.exports = class Query {
   constructor(props = {}) {
     this.props = {};
@@ -21,7 +19,7 @@ module.exports = class Query {
 
   propCheck(prop, ...checks) {
     checks.forEach((check) => {
-      if (this.props[check]) throw Boom.badRequest(`Cannot use "${prop}" while using "${check}"`);
+      if (this.props[check]) throw new Error(`Cannot use "${prop}" while using "${check}"`);
     });
   }
 
@@ -98,7 +96,7 @@ module.exports = class Query {
 
   skip(skip) {
     this.propCheck('skip', 'id');
-    if (this.isCursorPaging) throw Boom.badRequest('Cannot use "skip" while using Cursor-Style Pagination');
+    if (this.isCursorPaging) throw new Error('Cannot use "skip" while using Cursor-Style Pagination');
     this.isClassicPaging = true;
     this.props.skip = skip;
     return this;
@@ -106,7 +104,7 @@ module.exports = class Query {
 
   limit(limit) {
     this.propCheck('limit', 'id');
-    if (this.isCursorPaging) throw Boom.badRequest('Cannot use "limit" while using Cursor-Style Pagination');
+    if (this.isCursorPaging) throw new Error('Cannot use "limit" while using Cursor-Style Pagination');
     this.isClassicPaging = true;
     this.props.limit = limit;
     return this;
@@ -114,7 +112,7 @@ module.exports = class Query {
 
   first(first) {
     this.propCheck('first', 'id', 'last');
-    if (this.isClassicPaging) throw Boom.badRequest('Cannot use "first" while using Classic-Style Pagination');
+    if (this.isClassicPaging) throw new Error('Cannot use "first" while using Classic-Style Pagination');
     this.isCursorPaging = true;
     this.props.first = first + 2; // Adding 2 for pagination meta info (hasNext hasPrev)
     return this;
@@ -122,7 +120,7 @@ module.exports = class Query {
 
   last(last) {
     this.propCheck('last', 'id', 'first');
-    if (this.isClassicPaging) throw Boom.badRequest('Cannot use "last" while using Classic-Style Pagination');
+    if (this.isClassicPaging) throw new Error('Cannot use "last" while using Classic-Style Pagination');
     this.isCursorPaging = true;
     this.props.last = last + 2; // Adding 2 for pagination meta info (hasNext hasPrev)
     return this;
@@ -130,7 +128,7 @@ module.exports = class Query {
 
   before(before) {
     this.propCheck('before', 'id');
-    if (this.isClassicPaging) throw Boom.badRequest('Cannot use "before" while using Classic-Style Pagination');
+    if (this.isClassicPaging) throw new Error('Cannot use "before" while using Classic-Style Pagination');
     this.isCursorPaging = true;
     this.props.before = before;
     return this;
@@ -138,7 +136,7 @@ module.exports = class Query {
 
   after(after) {
     this.propCheck('after', 'id');
-    if (this.isClassicPaging) throw Boom.badRequest('Cannot use "after" while using Classic-Style Pagination');
+    if (this.isClassicPaging) throw new Error('Cannot use "after" while using Classic-Style Pagination');
     this.isCursorPaging = true;
     this.props.after = after;
     return this;

package/src/query/QueryBuilder.js

@@ -10,7 +10,7 @@ const { unravelObject } = require('../service/app.service');
 */
 module.exports = class QueryBuilder {
   constructor(resolver, model) {
-    this.terminated = false; // Prevent accidental re-use of the QueryBuilder
+    // this.terminated = false; // Prevent accidental re-use of the QueryBuilder
     this.query = new Query({ model, resolver });
 
     // Chainable commands
@@ -58,10 +58,10 @@ module.exports = class QueryBuilder {
   }
 
   execute(cmd, args) {
-    // Do not allow re-use
-    if (this.terminated) return Promise.reject(new Error('This query has already been executed'));
+    // // Do not allow re-use
+    // if (this.terminated) return Promise.reject(new Error('This query has already been executed'));
+    // this.terminated = true;
 
-    this.terminated = true;
     let method, crud, input, flags = {};
     const { id, where } = this.query.toObject();
 

package/src/query/QueryResolver.js

@@ -3,7 +3,7 @@ const Boom = require('../core/Boom');
 const QueryService = require('./QueryService');
 const DataService = require('../data/DataService');
 const { createSystemEvent } = require('../service/event.service');
-const { objectIntersectionEqual, mergeDeep, getGQLReturnType } = require('../service/app.service');
+const { mergeDeep, hashObject, getGQLReturnType } = require('../service/app.service');
 
 module.exports = class QueryResolver {
   constructor(query) {
@@ -76,19 +76,27 @@ module.exports = class QueryResolver {
   }
 
   async updateOne(query) {
-    const { model, match, input } = query.toObject();
+    const { model, match, input, flags } = query.toObject();
     const inputShape = model.getShape('update', 'input');
     const docShape = model.getShape('update', 'doc');
 
     return this.resolver.match(model).match(match).one({ required: true }).then((doc) => {
-      if (objectIntersectionEqual(doc, input)) return doc; // If no changes do not perform query
-
       const merged = mergeDeep(doc, input);
+      const docHash = hashObject(doc);
+      const skipUnchanged = get(flags, 'skipUnchanged');
+
+      // Prevent udpates when no data has changed
+      if (skipUnchanged && docHash === hashObject(merged)) return doc;
 
       return createSystemEvent('Mutation', { query: query.doc(doc).merged(merged) }, async () => {
+        // Prevent udpates when no data has changed (because merged can be mutated)
+        if (skipUnchanged && docHash === hashObject(merged)) return doc;
+
+        // Process
         const payload = model.shapeObject(inputShape, merged, query);
         await model.validateObject(inputShape, payload, query.payload(payload));
-        return this.resolver.resolve(query.$doc(model.shapeObject(docShape, payload, query)));
+        const $doc = model.shapeObject(docShape, payload, query, undefined, undefined, true);
+        return this.resolver.resolve(query.$doc($doc));
       });
     });
   }
@@ -187,7 +195,8 @@ module.exports = class QueryResolver {
     // Can only splice arrays
     const field = model.getField(key);
     const isArray = field.isArray();
-    if (!isArray) throw Boom.badRequest(`Cannot splice field '${model}.${field}'`);
+    const path = `${model}.${field}`;
+    if (!isArray) throw Boom.badRequest(`Cannot splice field '${path}'`, { path });
 
     return this.resolver.match(model).match(match).one({ required: true }).then(async (doc) => {
       const array = get(doc, key) || [];

package/src/query/QueryService.js

@@ -44,6 +44,7 @@ exports.resolveSortBy = (query) => {
   const { model, sort = {} } = query.toObject();
   const shape = model.getShape('create', 'sortBy');
   const $sort = model.shapeObject(shape, sort, query);
+  const deletions = [];
 
   // Because normalize casts the value (sometimes to an array) need special handling
   keyPaths($sort).forEach((path) => {
@@ -55,7 +56,7 @@ exports.resolveSortBy = (query) => {
 
     // If you need to sort by something that's in another FK document
     if (join) {
-      delete $sort[attr];
+      deletions.push(attr); // Keep track of what to delete
       query.joins(Object.assign(join, { as: `_.${field}`, left: true }));
       path = `_.${path}`;
     }
@@ -63,6 +64,9 @@ exports.resolveSortBy = (query) => {
     set($sort, path, val.toLowerCase() === 'asc' ? 1 : -1);
   });
 
+  // Delete the sorts on the "base" collection because you're sorting by _.path.to.it (above)
+  deletions.forEach(attr => delete $sort[attr]);
+
   return $sort;
 };
 

package/src/service/app.service.js

@@ -40,7 +40,7 @@ exports.isIdValue = value => exports.isScalarValue(value) || value instanceof Ob
 exports.mergeDeep = (...args) => DeepMerge.all(args, { isMergeableObject: obj => (exports.isPlainObject(obj) || Array.isArray(obj)), arrayMerge: smartMerge });
 exports.uniq = arr => [...new Set(arr.map(a => `${a}`))];
 exports.timeout = ms => new Promise(res => setTimeout(res, ms));
-exports.hashObject = obj => ObjectHash(obj, { respectType: false, respectFunctionNames: false, respectFunctionProperties: false, unorderedArrays: true, ignoreUnknown: true, replacer: r => (r instanceof ObjectId ? `${r}` : r) });
+exports.hashObject = obj => ObjectHash(obj, { respectType: false, respectFunctionNames: false, respectFunctionProperties: false, unorderedArrays: true, ignoreUnknown: true, replacer: r => (ObjectId.isValid(r) ? `${r}` : r) });
 exports.globToRegex = (glob, options = {}) => PicoMatch.makeRe(glob, { ...options, expandRange: (a, b) => `(${FillRange(a, b, { toRegex: true })})` });
 exports.globToRegexp = (glob, options = {}) => PicoMatch.toRegex(exports.globToRegex(glob, options));
 exports.toGUID = (model, id) => Buffer.from(`${model},${`${id}`}`).toString('base64');
@@ -130,9 +130,6 @@ exports.castCmp = (type, value) => {
   }
 };
 
-/**
- * Returns true if b is a subset of a
- */
 exports.objectContaining = (a, b) => {
   if (a === b) return true;
 
@@ -140,7 +137,7 @@ exports.objectContaining = (a, b) => {
     return exports.keyPathLeafs(b).every((leaf) => {
       const $a = _.get(a, leaf, { a: 'a' });
       const $b = _.get(b, leaf, { b: 'b' });
-      if (Array.isArray($b)) return $b.every(bb => exports.ensureArray($a).some(aa => exports.objectContaining(aa, bb)));
+      if (Array.isArray($b)) return $b.some(bb => exports.ensureArray($a).some(aa => exports.objectContaining(aa, bb)));
       if (exports.isScalarValue($a) && exports.isScalarValue($b)) return PicoMatch.isMatch(`${$a}`, `${$b}`, { nocase: true });
       return exports.hashObject($a) === exports.hashObject($b);
     });
@@ -149,23 +146,6 @@ exports.objectContaining = (a, b) => {
   return exports.hashObject(a) === exports.hashObject(b);
 };
 
-/**
- * Returns true if (b intersection a) are equal
- */
-exports.objectIntersectionEqual = (a, b) => {
-  if (a === b) return true;
-
-  if (exports.isPlainObject(b)) {
-    return exports.keyPathLeafs(b).every((leaf) => {
-      const $a = _.get(a, leaf, { a: 'a' });
-      const $b = _.get(b, leaf, { b: 'b' });
-      return exports.hashObject($a) === exports.hashObject($b);
-    });
-  }
-
-  return exports.hashObject(a) === exports.hashObject(b);
-};
-
 /**
  * Transform an object with dot.notation keys into an expanded object.
  * eg. { 'user.name': 'richard' } => { user: { name: 'richard' } }

package/src/service/event.service.js

@@ -29,7 +29,7 @@ const makeMiddleware = () => {
         query.match($$where);
       }
 
-      if (sort) {
+      if (sort && Object.keys(sort).length) {
         query.$sort(QueryService.resolveSortBy(query));
       }
 

package/src/service/schema.service.js

@@ -3,53 +3,6 @@
 // https://graphql.org/graphql-js/utilities/
 
 const { uniqWith } = require('lodash');
-const { GraphQLScalarType, GraphQLObjectType, GraphQLInterfaceType, GraphQLUnionType, GraphQLEnumType, GraphQLInputObjectType } = require('graphql');
-
-exports.getSchemaData = (schema) => {
-  const operations = ['Query', 'Mutation', 'Subscription'];
-
-  return Object.entries(schema.getTypeMap()).reduce((prev, [key, value]) => {
-    let type;
-
-    if (value instanceof GraphQLScalarType) {
-      type = 'scalars';
-    } else if (value instanceof GraphQLEnumType) {
-      type = 'enums';
-    } else if (value instanceof GraphQLUnionType) {
-      type = 'unions';
-    } else if (value instanceof GraphQLInterfaceType) {
-      type = 'interfaces';
-    } else if (value instanceof GraphQLInputObjectType) {
-      type = 'inputs';
-    } else if (value instanceof GraphQLObjectType) {
-      if (operations.includes(key)) {
-        type = 'operations';
-      } else {
-        type = 'models';
-      }
-    }
-
-    if (type) {
-      if (!key.startsWith('__')) {
-        prev[type][key] = value;
-      }
-    } else {
-      console.log(`Unknown schema type { ${key}: ${value} }`);
-    }
-
-    return prev;
-  }, {
-    enums: {},
-    models: {},
-    inputs: {},
-    unions: {},
-    scalars: {},
-    operations: {},
-    directives: {},
-    interfaces: {},
-    enumerations: {},
-  });
-};
 
 exports.identifyOnDeletes = (models, parentModel) => {
   return models.reduce((prev, model) => {