@coderich/autograph 0.9.6 → 0.9.9

package/package.json

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

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,80 +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];
-
-  // Edit
-  if (from && to) {
-    const arr = get(doc, key) || [];
-    if ($from.length > 1 && $to.length === 1) $to = Array.from($from).fill($to[0]);
-
-    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);
-    });
+  const op = from && to ? 'edit' : (from ? 'pull' : 'push'); // eslint-disable-line no-nested-ternary
+  const promises = [];
 
-    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) };
-      });
-    }
+  // Can only splice arrays
+  if (!field || !field.isArray()) return Promise.reject(Boom.badRequest(`Cannot splice field '${key}'`));
 
-    return { [key]: edits };
-  }
+  // 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;
 
-  // Pull
-  if (from) {
-    // key.split('.').reduce((prev, segment, i, arr) => {
-    //   if (prev == null) return prev;
+  // 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 map(prev, (data) => {
-    //     const $data = data[segment];
-    //     if (i < (arr.length - 1)) return $data;
-    //     remove($data, el => ($from || from).find(val => objectContaining(el, val)));
-    //     return $data;
-    //   });
-    // }, doc);
+  // 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]);
 
-    // return doc;
-    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/graphql/ast/Field.js

@@ -175,4 +175,9 @@ module.exports = class Field extends Node {
     type = this.isArray() ? `[${type}${this.isArrayElementRequired() ? '!' : ''}]` : type;
     return `${type}${req}`;
   }
+
+  getSubscriptionType() {
+    if (this.isFKReference()) return this.isArray() ? '[ID]' : 'ID';
+    return this.getGQLType();
+  }
 };

package/src/graphql/extension/api.js

@@ -90,7 +90,7 @@ module.exports = (schema) => {
         }
 
         type ${model.getName()}SubscriptionPayloadEventData {
-          ${getGQLWhereFields(model).map(field => `${field.getName()}: ${field.isFKReference() ? 'ID' : field.getGQLType()}`)}
+          ${getGQLWhereFields(model).map(field => `${field.getName()}: ${field.getSubscriptionType()}`)}
         }
 
         interface ${model.getName()}SubscriptionQuery {

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