@coderich/autograph 0.9.16 → 0.10.2

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # CHANGELOG
 
+## v0.10.x
+- 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)
+- Must pass makeExecutableSchema to Schema constructor
+
 ## v0.9.x
 - Subscriptions API
 - postMutation no longer mutates "doc" and adds "result"

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.9.16",
+  "version": "0.10.2",
   "description": "AutoGraph",
   "keywords": [
     "graphql",
@@ -23,8 +23,8 @@
   },
   "scripts": {
     "start": "APP_ROOT_PATH=$(pwd) node ./test/server",
-    "test": "APP_ROOT_PATH=$(pwd) ratchet test",
-    "test:debug": "APP_ROOT_PATH=$(pwd) node --inspect-brk ./node_modules/jest/bin/jest.js --watch --runInBand",
+    "test": "APP_ROOT_PATH=$(pwd) ratchet test --forceExit",
+    "test:debug": "APP_ROOT_PATH=$(pwd) node --inspect-brk ./node_modules/jest/bin/jest.js --watch --runInBand --logHeapUsage",
     "lint": "APP_ROOT_PATH=$(pwd) ratchet lint",
     "inspect": "APP_ROOT_PATH=$(pwd) node --expose-gc --inspect=9222 ./src/server",
     "ratchet": "ratchet"
@@ -37,22 +37,22 @@
     "fill-range": "^7.0.1",
     "glob": "^7.1.6",
     "graphql-fields": "^2.0.3",
-    "graphql-tools": "^7.0.5",
     "lodash": "^4.17.21",
+    "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.4",
+    "@coderich/ratchet": "^1.5.7",
+    "@graphql-tools/schema": "^8.3.14",
     "graphql": "^15.5.0",
-    "mongodb": "3.6.9",
-    "mongodb-memory-server": "^6.9.6",
+    "mongodb-memory-server": "^8.7.2",
     "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"
   },
   "repository": {
     "type": "git",

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 { isEmpty } = require('lodash');
 const Model = require('../data/Model');
-const Query = require('../query/Query');
-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 = {}) {
-    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,21 +52,22 @@ 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);
-          return new ResultSet(query, data);
+          return model.shapeObject(model.getShape(), data, query);
         });
       }
       default: {
         const key = model.idKey();
-        const { where, method } = query.toDriver();
+        const { where } = query.toDriver();
+        const lookupValue = where[key];
 
-        // This check is to avoid making a db call for no reason
-        if (Object.prototype.hasOwnProperty.call(where, key) && isEmpty(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([]);
@@ -99,15 +75,14 @@ module.exports = class Resolver {
           }
         }
 
-        // DB call
+        // 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) {
@@ -124,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,15 +1,12 @@
 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');
 
 // Export class
 module.exports = class extends Schema {
-  constructor(schema, stores) {
-    super(schema);
+  constructor(schema, stores, toExecutableSchema) {
+    super(schema, toExecutableSchema);
 
     // Create drivers
     this.drivers = Object.entries(stores).reduce((prev, [key, value]) => {
@@ -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/core/ServerResolver.js

@@ -1,101 +1,15 @@
-const GraphqlFields = require('graphql-fields');
-const Boom = require('./Boom');
-const { unrollGuid, guidToId, ensureArray, promiseChain } = require('../service/app.service');
-
-const normalizeQuery = (args = {}, info) => {
-  const query = { fields: GraphqlFields(info, {}, { processArguments: true }), ...args };
-  return query;
-  // const { fields = {} } = query;
-  // const { first, last, before, after } = args;
-  // return Object.assign(query, { pagination: { first, last, before, after }, fields: _.get(fields, 'edges.node') });
-};
+const { unrollGuid, guidToId } = require('../service/app.service');
 
 module.exports = class ServerResolver {
   constructor() {
-    // Getter
-    this.get = ({ autograph }, model, { id: guid }, required = false, info) => {
-      const query = { fields: GraphqlFields(info, {}, { processArguments: true }) };
-
-      return autograph.resolver.match(model).id(guidToId(autograph, guid)).merge(query).one().then((doc) => {
-        if (!doc && required) throw Boom.notFound(`${model} Not Found`);
-        return doc;
-      });
-    };
-
-    // Query
-    this.query = ({ autograph }, model, args, info) => autograph.resolver.match(model).merge(normalizeQuery(args, info)).many();
-    this.count = ({ autograph }, model, args, info) => autograph.resolver.match(model).merge(args).count();
+    // Queries
+    this.get = ({ autograph }, model, { id: guid }, required = false, query) => autograph.resolver.match(model).id(guidToId(autograph, guid)).select(query.fields).one({ required });
+    this.query = ({ autograph }, model, args, query) => autograph.resolver.match(model).select(query.fields).merge(args).many();
+    this.count = ({ autograph }, model, args, query) => autograph.resolver.match(model).merge(args).count();
 
     // Mutations
-    this.create = ({ autograph }, model, { input, meta }, query) => autograph.resolver.match(model).meta(meta).save(unrollGuid(autograph, model, input));
+    this.create = ({ autograph }, model, { input, meta }, query) => autograph.resolver.match(model).select(query.fields).meta(meta).save(unrollGuid(autograph, model, input));
     this.delete = ({ autograph }, model, { id: guid, meta }, query) => autograph.resolver.match(model).id(guidToId(autograph, guid)).select(query.fields).meta(meta).remove();
-
-    this.update = ({ autograph }, model, args, query) => {
-      const { resolver } = autograph;
-      const { id: guid, input, splice = {}, meta } = args;
-
-      return autograph.resolver.match(model).id(guidToId(autograph, guid)).select(query.fields).meta(meta).save(unrollGuid(autograph, model, input)).then((result) => {
-        if (!Object.keys(splice).length) return result;
-
-        const txn = resolver.transaction();
-
-        return promiseChain(Object.entries(splice).map(([key, { with: from, put: to, splice: subSplice }]) => {
-          to = to ? ensureArray(to) : to;
-          from = from ? ensureArray(from) : from;
-          const selectAll = Boolean(from && from.length === 0);
-
-          return async () => {
-            if (subSplice) {
-              console.log('we have to subSplice this');
-            }
-
-            if (selectAll) {
-              // Empty
-              if (to === null || (to && to.length === 0)) {
-                txn.match(model).id(result.id).select(query.fields).meta(meta).save({ [key]: to });
-                return txn.exec();
-              }
-
-              // Replace
-              if (to) {
-                const modelRef = model.getField(key).getModelRef();
-                const createTo = await resolver.match(modelRef).save(...to);
-                // const createTo = await Promise.all(to.map(el => modelRef.appendDefaultValues(el).then(r => modelRef.appendCreateFields(r, true))));
-                txn.match(model).id(result.id).select(query.fields).meta(meta).save({ [key]: createTo });
-                return txn.exec();
-              }
-
-              // Nonsense
-              return Promise.resolve([result]);
-            }
-
-            // Update
-            if (from && to) {
-              txn.match(model).id(result.id).meta(meta).splice(key, from, to);
-              return txn.exec();
-            }
-
-            // Remove
-            if (from && to === null) {
-              txn.match(model).id(result.id).meta(meta).splice(key, from);
-              return txn.exec();
-            }
-
-            // Add
-            if (!from && to) {
-              txn.match(model).id(result.id).meta(meta).splice(key, null, to);
-              return txn.exec();
-            }
-
-            // Nonsense
-            return Promise.resolve([result]);
-          };
-        })).then((results) => {
-          return txn.commit().then(() => {
-            return results.pop().pop();
-          });
-        });
-      });
-    };
+    this.update = ({ autograph }, model, { id: guid, meta, input }, query) => autograph.resolver.match(model).id(guidToId(autograph, guid)).select(query.fields).meta(meta).save(unrollGuid(autograph, model, input));
   }
 };

package/src/data/DataLoader.js

@@ -1,40 +1,81 @@
 const FBDataLoader = require('dataloader');
-const ResultSet = require('./ResultSet');
+const { map, ensureArray, hashObject } = require('../service/app.service');
 const Query = require('../query/Query');
-const { hashObject } = require('../service/app.service');
 
-// let counter = 0;
+const handleData = (data, model, query) => {
+  if (data == null || typeof data !== 'object') return data;
+  return model.deserialize(data, query);
+};
+
 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 });
+      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;
-      }, { 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));
-      });
+      }, {});
+
+      // 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));
+        }));
+      }
 
-      // return Promise.all(queries.map((query) => {
-      //   return driver.resolve(query.toDriver()).then((data) => {
-      //     return (data != null && typeof data === 'object' ? new ResultSet(query, data) : data);
-      //   });
-      // }));
+      /**
+       * 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: true,
       cacheKeyFn: query => hashObject(query.getCacheKey()),