@coderich/autograph 0.10.0 → 0.10.1

package/CHANGELOG.md

@@ -1,9 +1,27 @@
 # CHANGELOG
 
 ## v0.10.x
-- Removed model.tform() method
-- Removed embedApi directive and embedded API GQL
-- Hydrating fields apriori
+- Replaced ResultSet -> POJOs
+  - Removed all $$ magic resolver methods
+  - Removed all $ magic field methods
+  - Removed .toObject()
+- Removed embedded API completely
+- Removed Directives
+  - embedApi -> no replacement
+  - enforce -> use pipeline methods
+  - resolve -> use graphql resolvers
+  - @value -> use @field.instruct directive
+- Removed toId Transform -> use @field(id: '')
+- Removed Model.tform() -> use Model.shapeObject(shape, data)
+- Removed Resolver.toResultSet() -> ? TBD ?
+- Removed Transformer + Rule -> use Pipeline
+  - Removed many pre-defined rules + transformers
+  - Pre-defined names start with $ (eg. $toLowerCase)
+  - Moved "validator" to dev dependency -> isEmail
+- Added QueryBuilder.resolve() terminal command
+- Exported SchemaDecorator -> Schema
+- Removed embedded schema SystemEvents (internal emitter also removed)
+- Removed spread of arguments in QueryBuilder terminal commands (must pass in array)
 
 ## v0.9.x
 - Subscriptions API

package/index.js

@@ -1,19 +1,15 @@
 const Schema = require('./src/core/Schema');
-const SchemaDecorator = require('./src/core/SchemaDecorator');
 const GraphQL = require('./src/core/GraphQL');
 const Resolver = require('./src/core/Resolver');
-const Rule = require('./src/core/Rule');
+const Pipeline = require('./src/data/Pipeline');
 const Driver = require('./src/driver');
-const Transformer = require('./src/core/Transformer');
 const { eventEmitter: Emitter } = require('./src/service/event.service');
 
 module.exports = {
   Schema,
-  SchemaDecorator,
   GraphQL,
   Resolver,
-  Rule,
   Driver,
-  Transformer,
   Emitter,
+  Pipeline,
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@coderich/autograph",
   "author": "Richard Livolsi (coderich)",
-  "version": "0.10.0",
+  "version": "0.10.1",
   "description": "AutoGraph",
   "keywords": [
     "graphql",
@@ -42,8 +42,7 @@
     "mongodb": "^4.8.0",
     "object-hash": "^2.0.1",
     "picomatch": "^2.1.1",
-    "uuid": "^3.3.3",
-    "validator": "^12.2.0"
+    "uuid": "^3.3.3"
   },
   "devDependencies": {
     "@coderich/ratchet": "^1.5.7",
@@ -52,7 +51,8 @@
     "neo4j-driver": "^4.0.0",
     "neodb": "^3.0.0",
     "redis": "^2.8.0",
-    "redis-mock": "^0.47.0"
+    "redis-mock": "^0.47.0",
+    "validator": "^13.7.0"
   },
   "peerDependencies": {
     "graphql": "*"

package/src/core/EventEmitter.js

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

package/src/core/Resolver.js

@@ -1,22 +1,22 @@
 const Model = require('../data/Model');
-const Query = require('../query/Query');
-const ResultSet = require('../data/ResultSet');
-const DataHydrator = require('../data/stream/DataHydrator');
 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 = {}) {
-    this.models = schema.getModels();
     this.schema = schema;
     this.context = context;
+    this.models = schema.getModels();
     this.loaders = this.models.reduce((prev, model) => prev.set(`${model}`, new DataLoader(this, model)), new Map());
+  }
 
-    //
-    this.getSchema = () => this.schema;
-    this.getContext = () => this.context;
+  getSchema() {
+    return this.schema;
+  }
+
+  getContext() {
+    return this.context;
   }
 
   /**
@@ -38,31 +38,6 @@ 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;
-    //   },
-    // });
   }
 
   /**
@@ -77,31 +52,37 @@ module.exports = class Resolver {
   }
 
   resolve(query) {
-    const { model, crud } = query.toObject();
+    const { model, crud, method } = query.toObject();
 
     switch (crud) {
       case 'create': case 'update': case 'delete': {
         return model.getDriver().resolve(query.toDriver()).then((data) => {
           this.clear(model);
-          data = model.shape(data, 'deserialize');
-          return new DataHydrator(query, data);
+          return model.shapeObject(model.getShape(), data, query);
         });
       }
       default: {
-        // This is needed in SF tests...
         const key = model.idKey();
-        const { where, method } = query.toDriver();
-        if (Object.prototype.hasOwnProperty.call(where, key) && where[key] == null) return Promise.resolve(method === 'findMany' ? [] : null);
-
-        //
+        const { where } = query.toDriver();
+        const lookupValue = where[key];
+
+        // This is a shortcut to prevent making unnecessary query
+        if (Object.prototype.hasOwnProperty.call(where, key) && (lookupValue == null || (Array.isArray(lookupValue) && lookupValue.length === 0))) {
+          switch (method) {
+            case 'count': return Promise.resolve(0);
+            case 'findMany': return Promise.resolve([]);
+            default: return Promise.resolve(null);
+          }
+        }
+
+        // Go through DataLoader to cache results
         return this.loaders.get(`${model}`).load(query);
       }
     }
   }
 
   toModel(model) {
-    const $model = model instanceof Model ? model : this.schema.getModel(model);
-    return $model;
+    return model instanceof Model ? model : this.schema.getModel(model);
   }
 
   toModelMarked(model) {
@@ -118,23 +99,25 @@ module.exports = class Resolver {
     return entity;
   }
 
-  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);
-  }
+  // toResultSet(model, data, method) {
+  //   const crud = ['get', 'find', 'count'].indexOf(method) > -1 ? 'read' : method;
+  //   const doc = model.shape(data);
+  //   const result = doc;
+  //   const merged = doc;
+
+  //   return createSystemEvent('Response', {
+  //     model,
+  //     crud,
+  //     method,
+  //     result,
+  //     doc,
+  //     merged,
+  //     resolver: this,
+  //     key: `${method}${model}`,
+  //     context: this.getContext(),
+  //     query: query.doc(result).merged(result),
+  //   }, () => result);
+  // }
 
   // DataLoader Proxy Methods
   clear(model) {

package/src/core/Schema.js

@@ -1,8 +1,5 @@
 const Model = require('../data/Model');
 const Schema = require('../graphql/ast/Schema');
-const apiExt = require('../graphql/extension/api');
-const typeExt = require('../graphql/extension/type');
-const frameworkExt = require('../graphql/extension/framework');
 const { identifyOnDeletes } = require('../service/schema.service');
 const { createSystemEvent } = require('../service/event.service');
 
@@ -23,9 +20,6 @@ module.exports = class extends Schema {
         },
       });
     }, {});
-
-    // Create models
-    this.createModels();
   }
 
   setup() {
@@ -43,38 +37,11 @@ module.exports = class extends Schema {
     });
   }
 
-  createModels() {
+  initialize() {
+    super.initialize();
     this.models = super.getModels().map(model => new Model(this, model, this.drivers[model.getDriverName()]));
+    this.models.forEach(model => model.initialize());
     this.models.forEach(model => model.referentialIntegrity(identifyOnDeletes(this.models, model)));
-    this.modelsByName = this.models.reduce((prev, model) => Object.assign(prev, { [model.getName()]: model }), {});
-    this.modelsByKey = this.models.reduce((prev, model) => Object.assign(prev, { [model.getKey()]: model }), {});
-  }
-
-  loadDir(dir, options) {
-    super.loadDir(dir, options);
-    this.createModels();
-    return this;
-  }
-
-  extend(...schemas) {
-    super.extend(...schemas);
-    this.createModels();
     return this;
   }
-
-  /**
-   * Called a runtime to get the full server api schema. Done this way because the
-   * end-user needs a chance to call Transformer.factory() etc (thus cannot be moved to constructor)
-   */
-  getServerApiSchema() {
-    this.extend(frameworkExt(this), typeExt(this));
-    this.sextend(apiExt(this));
-    return super.getSchema();
-  }
-
-  makeServerApiSchema() {
-    this.extend(frameworkExt(this), typeExt(this));
-    this.sextend(apiExt(this));
-    return super.makeExecutableSchema();
-  }
 };

package/src/data/DataLoader.js

@@ -1,44 +1,83 @@
 const FBDataLoader = require('dataloader');
-const DataHydrator = require('./stream/DataHydrator');
-// const ResultSet = require('./ResultSet');
-// const Query = require('../query/Query');
+const { map, ensureArray, hashObject } = require('../service/app.service');
+const Query = require('../query/Query');
 
-const { hashObject } = require('../service/app.service');
+const handleData = (data, model, query) => {
+  if (data == null || typeof data !== 'object') return data;
+  return model.deserialize(data, query);
+};
 
-// let counter = 0;
 module.exports = class DataLoader extends FBDataLoader {
   constructor(resolver, model) {
-    // const idKey = model.idKey();
     const driver = model.getDriver();
 
     return new FBDataLoader((queries) => {
-      // // The idea is to group the "findOne by id" queries together to make 1 query instead
-      // const { findOneByIdQueries, allOtherQueries } = queries.reduce((prev, query, i) => {
-      //   const { id, method } = query.toObject();
-      //   const key = method === 'findOne' && id ? 'findOneByIdQueries' : 'allOtherQueries';
-      //   prev[key].push({ id, query, i });
-      //   return prev;
-      // }, { findOneByIdQueries: [], allOtherQueries: [] });
-
-      // // Aggregate ids
-      // const ids = Array.from(new Set(findOneByIdQueries.map(el => `${el.id}`)));
-      // const batchQuery = new Query({ resolver, model, method: 'findMany', crud: 'read' });
-      // const batchWhere = model.transform(batchQuery, { id: ids }, 'serialize', true);
-      // const promises = [Promise.all(allOtherQueries.map(({ query, i }) => driver.resolve(query.toDriver()).then(data => ({ data, query, i }))))];
-      // if (ids.length) promises.push(driver.resolve(batchQuery.where(batchWhere).toDriver()).then(results => findOneByIdQueries.map(({ query, id, i }) => ({ i, query, data: results.find(r => `${r[idKey]}` === `${id}`) || null }))));
-
-      // return Promise.all(promises).then((results) => {
-      //   const sorted = results.flat().filter(Boolean).sort((a, b) => a.i - b.i);
-      //   return sorted.map(({ query, data }) => (data != null && typeof data === 'object' ? new ResultSet(query, data) : data));
-      // });
-
-      return Promise.all(queries.map((query) => {
-        return driver.resolve(query.toDriver()).then((data) => {
-          return (data != null && typeof data === 'object' ? new DataHydrator(query, data) : data);
-        });
-      }));
+      let performBatchQuery = false; // If we don't have to batch it's faster to resolve normal
+      const defaultBatchName = '__default__'; // Something that won't collide with an actual field name
+
+      /**
+       * Batch queries can save resources and network round-trip latency. However, we have to be careful to
+       * preserve the order and adhere to the DataLoader API. This step simply creates a map of batch
+       * queries to run; saving the order ("i") along with useful meta information
+       */
+      const batchQueries = queries.reduce((prev, query, i) => {
+        const { batch = defaultBatchName, where, cmd } = query.toObject();
+        const key = batch && (cmd === 'one' || cmd === 'many') ? batch : defaultBatchName;
+        if (key !== defaultBatchName) performBatchQuery = true;
+        prev[key] = prev[key] || [];
+        prev[key].push({ query, where, cmd, i });
+        return prev;
+      }, {});
+
+      // Don't batch unless it's worth it!
+      if (!performBatchQuery) {
+        return Promise.all(queries.map((query) => {
+          return driver.resolve(query.toDriver()).then(data => handleData(data, model, query));
+        }));
+      }
+
+      /**
+       * We have reduced the number of queries down to a smaller set of batch queries to run. The dance
+       * performed below retreives the data and then expands the results back into the original queries
+       */
+      const whereShape = model.getShape('create', 'where');
+
+      // console.log(Object.entries(batchQueries).map(([key, value]) => ({ [key]: value.length })));
+
+      return Promise.all(Object.entries(batchQueries).map(([key, values]) => {
+        switch (key) {
+          case defaultBatchName: {
+            return values.map(({ query, i }) => driver.resolve(query.toDriver()).then(data => handleData(data, model, query)).then(data => ({ data, i })));
+          }
+          default: {
+            const keys = Array.from(new Set(values.map(({ where }) => map(where[key], el => `${el}`)).flat()));
+            const batchQuery = new Query({ resolver, model, method: 'findMany', crud: 'read' });
+            const batchWhere = model.shapeObject(whereShape, { [key]: keys }, batchQuery); // This will add back instructs etc
+
+            return driver.resolve(batchQuery.where(batchWhere).toDriver()).then(data => handleData(data, model, batchQuery)).then((results) => {
+              // One-time data transformation on results to make matching back faster (below)
+              const resultsByKey = results.reduce((prev, row) => {
+                ensureArray(row[key]).forEach((id) => {
+                  prev[id] = prev[id] || [];
+                  prev[id].push(row);
+                });
+                return prev;
+              }, {});
+
+              // Match back
+              return values.map(({ where, cmd, i }) => {
+                const targets = ensureArray(where[key]).map(t => `${t}`);
+                const data = targets.map(t => resultsByKey[t] || null).flat();
+                return { i, data: cmd === 'many' ? data.filter(d => d != null) : data[0] };
+              });
+            });
+          }
+        }
+      }).flat()).then((results) => {
+        return results.flat().sort((a, b) => a.i - b.i).map(({ data }) => data);
+      });
     }, {
-      cache: false,
+      cache: true,
       cacheKeyFn: query => hashObject(query.getCacheKey()),
     });
   }

package/src/data/DataService.js

@@ -1,11 +1,19 @@
-const { remove } = require('lodash');
-const Boom = require('../core/Boom');
-const { isPlainObject, objectContaining, mergeDeep, map } = require('../service/app.service');
+const { get, remove } = require('lodash');
+const { map, isPlainObject, objectContaining, mergeDeep, ensureArray, keyPaths } = require('../service/app.service');
 
-exports.paginateResultSet = (rs, first, after, last, before) => {
+exports.paginateResultSet = (rs, query) => {
+  const { first, after, last, before, sort } = query.toObject();
+  const sortPaths = keyPaths(sort);
+  const limiter = first || last;
   let hasNextPage = false;
   let hasPreviousPage = false;
-  const limiter = first || last;
+
+  // Add $$cursor data
+  map(rs, (doc) => {
+    const sortValues = sortPaths.reduce((prv, path) => Object.assign(prv, { [path]: get(doc, path) }), {});
+    const sortJSON = JSON.stringify(sortValues);
+    doc.$$cursor = Buffer.from(sortJSON).toString('base64');
+  });
 
   // First try to take off the "bookends" ($gte | $lte)
   if (rs.length && rs[0].$$cursor === after) {
@@ -34,64 +42,57 @@ exports.paginateResultSet = (rs, first, after, last, before) => {
     }
   }
 
-  return { hasNextPage, hasPreviousPage };
+  // Add $$pageInfo data (hidden)
+  return Object.defineProperties(rs, {
+    $$pageInfo: {
+      get() {
+        return {
+          startCursor: get(rs, '0.$$cursor', ''),
+          endCursor: get(rs, `${rs.length - 1}.$$cursor`, ''),
+          hasPreviousPage,
+          hasNextPage,
+        };
+      },
+      enumerable: false,
+    },
+  });
 };
 
-/**
- * @param from <Array>
- * @param to <Array>
- */
-exports.spliceEmbeddedArray = (query, doc, key, from, to) => {
-  const { model } = query.toObject();
-  const field = model.getField(key);
-  const modelRef = field.getModelRef();
+exports.spliceEmbeddedArray = (array, from, to) => {
   const op = from && to ? 'edit' : (from ? 'pull' : 'push'); // eslint-disable-line no-nested-ternary
-  const promises = [];
-
-  // Can only splice arrays
-  if (!field || !field.isArray()) return Promise.reject(Boom.badRequest(`Cannot splice field '${key}'`));
-
-  // 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 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)));
 
   // 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]);
-
-  // 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;
+  if (from && from.length > 1 && to && to.length === 1) to = Array.from(from).fill(to[0]);
 
-    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
-
-      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;
-        }
-      }
+  switch (op) {
+    case 'edit': {
+      array.forEach((el, j) => {
+        ensureArray(from).forEach((val, k) => {
+          if (objectContaining(el, val)) array[j] = isPlainObject(el) ? mergeDeep(el, ensureArray(to)[k]) : ensureArray(to)[k];
+        });
+      });
+      break;
+    }
+    // case 'edit': {
+    //   ensureArray(from).forEach((f, i) => {
+    //     const t = ensureArray(to)[i];
+    //     const indexes = array.map((el, j) => (el === f ? j : -1)).filter(index => index !== -1);
+    //     indexes.forEach(index => (array[index] = t));
+    //   });
+    //   break;
+    // }
+    case 'push': {
+      array.push(...to);
+      break;
+    }
+    case 'pull': {
+      remove(array, el => from.find(val => objectContaining(el, val)));
+      break;
+    }
+    default: {
+      break;
+    }
+  }
 
-      return Promise.all(promises);
-    });
-  }, doc);
+  return array;
 };