@coderich/autograph 0.9.3 → 0.9.7

package/CHANGELOG.md

@@ -3,6 +3,7 @@
 ## v0.9.x
 - Subscriptions API
 - postMutation no longer mutates "doc" and adds "result"
+- Added onDelete defer option
 
 ## v0.8.x
 - Engine 14+

package/package.json

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

package/src/core/Resolver.js

@@ -4,6 +4,7 @@ const ResultSet = require('../data/ResultSet');
 const DataLoader = require('../data/DataLoader');
 const DataTransaction = require('../data/DataTransaction');
 const QueryBuilder = require('../query/QueryBuilder');
+const { createSystemEvent } = require('../service/event.service');
 
 module.exports = class Resolver {
   constructor(schema, context = {}) {
@@ -36,6 +37,31 @@ module.exports = class Resolver {
    */
   raw(model) {
     return this.toModelEntity(model).raw();
+    // const entity = this.toModelEntity(model);
+    // const driver = entity.raw();
+    // if (!method) return driver;
+
+    // const resolver = this;
+    // const crud = ['get', 'find', 'count'].indexOf(method) > -1 ? 'read' : method;
+    // const query = new Query({ model: entity, resolver, crud });
+
+    // return new Proxy(driver, {
+    //   get(target, prop, rec) {
+    //     const value = Reflect.get(target, prop, rec);
+
+    //     if (typeof value === 'function') {
+    //       return (...args) => {
+    //         return value.bind(target)(...args).then((result) => {
+    //           const doc = resolver.toResultSet(model, result);
+    //           createSystemEvent('Response', { method, query: query.doc(doc) });
+    //           return result;
+    //         });
+    //       };
+    //     }
+
+    //     return value;
+    //   },
+    // });
   }
 
   /**
@@ -58,8 +84,8 @@ module.exports = class Resolver {
       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);
+        const { where, method } = query.toDriver();
+        if (Object.prototype.hasOwnProperty.call(where, key) && where[key] == null) return Promise.resolve(method === 'findMany' ? [] : null);
 
         //
         return this.loaders.get(`${model}`).load(query);
@@ -86,8 +112,22 @@ module.exports = class Resolver {
     return entity;
   }
 
-  toResultSet(model, data) {
-    return new ResultSet(new Query({ model: this.toModel(model), resolver: this }), data);
+  toResultSet(model, data, method) {
+    const crud = ['get', 'find', 'count'].indexOf(method) > -1 ? 'read' : method;
+    const query = new Query({ model: this.toModel(model), resolver: this, crud });
+    const result = new ResultSet(query, data);
+    return createSystemEvent('Response', {
+      model,
+      crud,
+      method,
+      result,
+      doc: result,
+      merged: result,
+      resolver: this,
+      key: `${method}${model}`,
+      context: this.getContext(),
+      query: query.doc(result).merged(result),
+    }, () => result);
   }
 
   // DataLoader Proxy Methods

package/src/core/Schema.js

@@ -50,8 +50,8 @@ module.exports = class extends Schema {
     this.modelsByKey = this.models.reduce((prev, model) => Object.assign(prev, { [model.getKey()]: model }), {});
   }
 
-  loadDir(dir) {
-    super.loadDir(dir);
+  loadDir(dir, options) {
+    super.loadDir(dir, options);
     this.createModels();
     return this;
   }

package/src/data/DataService.js

@@ -1,7 +1,6 @@
-const { get, remove } = require('lodash');
+const { remove } = require('lodash');
 const Boom = require('../core/Boom');
-const { createSystemEvent } = require('../service/event.service');
-const { isPlainObject, objectContaining, mergeDeep, hashObject } = require('../service/app.service');
+const { isPlainObject, objectContaining, mergeDeep, map } = require('../service/app.service');
 
 exports.paginateResultSet = (rs, first, after, last, before) => {
   let hasNextPage = false;
@@ -38,68 +37,61 @@ exports.paginateResultSet = (rs, first, after, last, before) => {
   return { hasNextPage, hasPreviousPage };
 };
 
-exports.spliceEmbeddedArray = async (query, doc, key, from, to) => {
+/**
+ * @param from <Array>
+ * @param to <Array>
+ */
+exports.spliceEmbeddedArray = (query, doc, key, from, to) => {
   const { model } = query.toObject();
   const field = model.getField(key);
-  if (!field || !field.isArray()) return Promise.reject(Boom.badRequest(`Cannot splice field '${key}'`));
-
   const modelRef = field.getModelRef();
-  const $from = model.deserialize(query, { [key]: from })[key];
-  let $to = model.deserialize(query, { [key]: to })[key];
+  const op = from && to ? 'edit' : (from ? 'pull' : 'push'); // eslint-disable-line no-nested-ternary
+  const promises = [];
 
-  // Edit
-  if (from && to) {
-    const arr = get(doc, key) || [];
-    if ($from.length > 1 && $to.length === 1) $to = Array.from($from).fill($to[0]);
+  // Can only splice arrays
+  if (!field || !field.isArray()) return Promise.reject(Boom.badRequest(`Cannot splice field '${key}'`));
 
-    const edits = arr.map((el) => {
-      return $from.reduce((prev, val, i) => {
-        if (objectContaining(el, val)) return isPlainObject(prev) ? mergeDeep(prev, $to[i]) : $to[i];
-        return prev;
-      }, el);
-    });
+  // We have to deserialize because this normalizes the data (casting etc)
+  let $to = model.deserialize(query, { [key]: to })[key] || to;
+  const $from = model.deserialize(query, { [key]: from })[key] || from;
 
-    if (field.isEmbedded()) {
-      return Promise.all(edits.map((edit, i) => {
-        if (hashObject(edit) !== hashObject(arr[i])) {
-          return createSystemEvent('Mutation', { method: 'update', query: query.clone().model(modelRef).input(edit).doc(doc) }, () => {
-            edit = modelRef.appendDefaultFields(query, modelRef.appendCreateFields(edit, true));
-            return modelRef.validate(query, edit).then(() => edit);
-          });
-        }
-
-        return Promise.resolve(edit);
-      })).then((results) => {
-        return { [key]: mergeDeep(edits, results) };
-      });
-    }
+  // If it's embedded we need to append default/create fields for insertion
+  if ($to && field.isEmbedded()) $to = $to.map(el => modelRef.appendDefaultFields(query, modelRef.appendCreateFields(el, true)));
 
-    return { [key]: edits };
-  }
+  // Convenience so the user does not have to explicity type out the same value over and over to replace
+  if ($from && $from.length > 1 && $to && $to.length === 1) $to = Array.from($from).fill($to[0]);
 
-  // Pull
-  if (from) {
-    const data = { [key]: get(doc, key) || [] };
-    remove(data[key], el => $from.find(val => objectContaining(el, val)));
-    return data;
-  }
+  // Traverse the document till we find the segment to modify (in place)
+  return key.split('.').reduce((prev, segment, i, arr) => {
+    if (prev == null) return prev;
 
-  // Push
-  if (to) {
-    if (field.isEmbedded()) {
-      return Promise.all($to.map((input) => {
-        return createSystemEvent('Mutation', { method: 'create', query: query.clone().model(modelRef).input(input).doc(doc) }, () => {
-          input = modelRef.appendDefaultFields(query, modelRef.appendCreateFields(input, true));
-          return modelRef.validate(query, input).then(() => input);
-        });
-      })).then((results) => {
-        return { [key]: (get(doc, key) || []).concat(...results) };
-      });
-    }
+    return map(prev, (data) => {
+      if (i < (arr.length - 1)) return data[segment]; // We have not found the target segment yet
+      data[segment] = data[segment] || []; // Ensuring target segment is an array
 
-    return { [key]: (get(doc, key) || []).concat($to) };
-  }
+      switch (op) {
+        case 'edit': {
+          data[segment].forEach((el, j) => {
+            $from.forEach((val, k) => {
+              if (objectContaining(el, val)) data[segment][j] = isPlainObject(el) ? mergeDeep(el, $to[k]) : $to[k];
+            });
+          });
+          break;
+        }
+        case 'push': {
+          data[segment].push(...$to);
+          break;
+        }
+        case 'pull': {
+          remove(data[segment], el => $from.find(val => objectContaining(el, val)));
+          break;
+        }
+        default: {
+          break;
+        }
+      }
 
-  // Should never get here
-  return Promise.reject(new Error('Invalid spliceEmbeddedArray'));
+      return Promise.all(promises);
+    });
+  }, doc);
 };

package/src/data/ResultSet.js

@@ -4,6 +4,7 @@ const { map, ensureArray, keyPaths, mapPromise, toGUID, hashObject } = require('
 
 module.exports = class ResultSet {
   constructor(query, data, adjustForPagination = true) {
+    if (data == null) return data;
     const { resolver, model, sort, first, after, last, before } = query.toObject();
     const fields = model.getFields().filter(f => f.getName() !== 'id');
 

package/src/graphql/ast/Schema.js

@@ -106,12 +106,12 @@ module.exports = class Schema extends Node {
     return this.schema.context;
   }
 
-  loadDir(dir) {
+  loadDir(dir, options) {
     // Typedefs
-    const typeDefs = Glob.sync(`${dir}/**/*.{gql,graphql}`).map(file => loadFile(file)).join('\n\n');
+    const typeDefs = Glob.sync(`${dir}/**/*.{gql,graphql}`, options).map(file => loadFile(file)).join('\n\n');
 
     // Possibly full schema definitions
-    const schema = Glob.sync(`${dir}/**/*.js`).map(file => reqFile(file)).reduce((prev, data) => {
+    const schema = Glob.sync(`${dir}/**/*.js`, options).map(file => reqFile(file)).reduce((prev, data) => {
       return Merge(prev, data);
     }, {
       typeDefs: typeDefs.length ? typeDefs : undefined,

package/src/graphql/extension/framework.js

@@ -11,7 +11,7 @@ module.exports = (schema) => {
       enum AutoGraphTransformEnum  { ${Object.keys(Transformer.getInstances()).join(' ')} }
       enum AutoGraphAuthzEnum { private protected public }
       enum AutoGraphValueScopeEnum { self context }
-      enum AutoGraphOnDeleteEnum { cascade nullify restrict }
+      enum AutoGraphOnDeleteEnum { cascade nullify restrict defer }
       enum AutoGraphIndexEnum { unique }
 
       directive @model(

package/src/query/QueryBuilder.js

@@ -78,7 +78,7 @@ module.exports = class QueryBuilder {
         break;
       }
       case 'push': case 'pull': case 'splice': {
-        crud = 'update'; // Your logics wants this to be a simple "update". Sub documents systemEvents will emit either "create" or "udpate"
+        crud = 'update'; // Your logic wants this to be a simple "update". Sub documents systemEvents will emit either "create" or "udpate"
         method = id ? `${cmd}One` : `${cmd}Many`;
         break;
       }

package/src/query/QueryResolver.js

@@ -130,17 +130,33 @@ module.exports = class QueryResolver {
     });
   }
 
+  spliceOne(query) {
+    const { args } = query.toObject();
+    const [key, ...values] = args;
+    return this.splice(query.args([key, ...values]));
+  }
+
+  spliceMany(query) {
+    const { model, match, transaction, args, flags } = query.toObject();
+    const [key, ...values] = args;
+
+    return this.resolver.match(model).match(match).flags(flags).many().then((docs) => {
+      const txn = this.resolver.transaction(transaction);
+      docs.forEach(doc => txn.match(model).id(doc.id).splice(key, ...values));
+      return txn.run();
+    });
+  }
+
   splice(query) {
     const { model, match, args, flags } = query.toObject();
     const [key, from, to] = args;
 
     return this.resolver.match(model).match(match).flags(flags).one({ required: true }).then(async (doc) => {
-      const data = await DataService.spliceEmbeddedArray(query, doc, key, from, to);
-      const merged = mergeDeep(doc, data);
+      await DataService.spliceEmbeddedArray(query, doc, key, from, to);
 
-      return createSystemEvent('Mutation', { method: 'splice', query: query.doc(doc).input(data).merged(merged) }, async () => {
-        await model.validate(query, data);
-        const $doc = mergeDeep(model.serialize(query, doc, true), model.serialize(query, data, true));
+      return createSystemEvent('Mutation', { method: 'splice', query: query.doc(doc).merged(doc) }, async () => {
+        await model.validate(query, doc);
+        const $doc = model.serialize(query, doc, true);
         return this.resolver.resolve(query.method('updateOne').doc(doc).$doc($doc));
       });
     });

package/src/query/QueryService.js

@@ -111,6 +111,11 @@ exports.resolveReferentialIntegrity = (query) => {
             txn.match(ref).where($where).flags(flags).count().then(count => (count ? reject(new Error('Restricted')) : count));
             break;
           }
+          case 'defer': {
+            // Defer to the embedded object
+            // Marks the field as an onDelete candidate otherwise it (and the embedded object) will get skipped
+            break;
+          }
           default: throw new Error(`Unknown onDelete operator: '${op}'`);
         }
       });