@coderich/autograph 0.9.10 → 0.10.0

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # CHANGELOG
 
+## v0.10.x
+- Removed model.tform() method
+- Removed embedApi directive and embedded API GQL
+- Hydrating fields apriori
+
 ## v0.9.x
 - Subscriptions API
 - postMutation no longer mutates "doc" and adds "result"

package/index.js

@@ -1,4 +1,5 @@
 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');
@@ -8,6 +9,7 @@ const { eventEmitter: Emitter } = require('./src/service/event.service');
 
 module.exports = {
   Schema,
+  SchemaDecorator,
   GraphQL,
   Resolver,
   Rule,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@coderich/autograph",
   "author": "Richard Livolsi (coderich)",
-  "version": "0.9.10",
+  "version": "0.10.0",
   "description": "AutoGraph",
   "keywords": [
     "graphql",
@@ -23,13 +23,14 @@
   },
   "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"
   },
   "dependencies": {
+    "@graphql-tools/schema": "^8.3.14",
     "@hapi/boom": "^9.1.0",
     "axios": "^0.21.4",
     "dataloader": "^2.0.0",
@@ -37,23 +38,25 @@
     "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"
   },
   "devDependencies": {
-    "@coderich/ratchet": "^1.5.4",
+    "@coderich/ratchet": "^1.5.7",
     "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"
   },
+  "peerDependencies": {
+    "graphql": "*"
+  },
   "repository": {
     "type": "git",
     "url": "git@github.com:coderich/autograph.git"

package/src/core/Resolver.js

@@ -1,6 +1,7 @@
 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');
@@ -71,6 +72,10 @@ module.exports = class Resolver {
     return new DataTransaction(this, parentTxn);
   }
 
+  disconnect(model) {
+    return this.toModelEntity(model).getDriver().disconnect();
+  }
+
   resolve(query) {
     const { model, crud } = query.toObject();
 
@@ -78,7 +83,8 @@ module.exports = class Resolver {
       case 'create': case 'update': case 'delete': {
         return model.getDriver().resolve(query.toDriver()).then((data) => {
           this.clear(model);
-          return new ResultSet(query, data);
+          data = model.shape(data, 'deserialize');
+          return new DataHydrator(query, data);
         });
       }
       default: {

package/src/core/SchemaDecorator.js

@@ -0,0 +1,46 @@
+const Model = require('../data/Model');
+const SchemaDecorator = require('../graphql/ast/SchemaDecorator');
+const { identifyOnDeletes } = require('../service/schema.service');
+const { createSystemEvent } = require('../service/event.service');
+
+// Export class
+module.exports = class extends SchemaDecorator {
+  constructor(schema, stores) {
+    super(schema);
+
+    // Create drivers
+    this.drivers = Object.entries(stores).reduce((prev, [key, value]) => {
+      const { Driver } = value;
+
+      return Object.assign(prev, {
+        [key]: {
+          dao: new Driver(value, this),
+          idKey: Driver.idKey,
+          idValue: Driver.idValue,
+        },
+      });
+    }, {});
+  }
+
+  setup() {
+    return createSystemEvent('Setup', this, () => {
+      const entities = this.models.filter(m => m.isEntity());
+
+      // Create model indexes
+      return Promise.all(entities.map(async (model) => {
+        const key = model.getKey();
+        const indexes = model.getIndexes();
+        const driver = model.getDriver();
+        if (driver.createCollection) await driver.createCollection(key);
+        return driver.createIndexes(key, indexes);
+      }));
+    });
+  }
+
+  initialize() {
+    super.initialize();
+    this.models = super.getModels().map(model => new Model(this, model, this.drivers[model.getDriverName()]));
+    this.models.forEach(model => model.referentialIntegrity(identifyOnDeletes(this.models, model)));
+    return this;
+  }
+};

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,42 +1,44 @@
 const FBDataLoader = require('dataloader');
-const ResultSet = require('./ResultSet');
-const Query = require('../query/Query');
+const DataHydrator = require('./stream/DataHydrator');
+// const ResultSet = require('./ResultSet');
+// const Query = require('../query/Query');
+
 const { hashObject } = require('../service/app.service');
 
 // let counter = 0;
 module.exports = class DataLoader extends FBDataLoader {
   constructor(resolver, model) {
-    const idKey = model.idKey();
+    // 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: [] });
+      // // 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 }))));
+      // // 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(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 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);
+        });
+      }));
     }, {
-      cache: true,
+      cache: false,
       cacheKeyFn: query => hashObject(query.getCacheKey()),
     });
   }

package/src/data/Model.js

@@ -126,6 +126,9 @@ module.exports = class extends Model {
     });
   }
 
+  /**
+   * Normalizes data by renaming keys and serdes on field values (unless keysOnly)
+   */
   normalize(query, data, serdes = (() => { throw new Error('No Sir Sir SerDes!'); }), keysOnly = false) {
     // Transform all the data
     return map(data, (doc) => {
@@ -140,6 +143,25 @@ module.exports = class extends Model {
     });
   }
 
+  getShape(serdes = 'deserialize') {
+    return this.getSelectFields().map((field) => {
+      const [from, to] = serdes === 'serialize' ? [field.getName(), field.getKey()] : [field.getKey(), field.getName()];
+      return { from, to, type: field.getDataType(), isArray: field.isArray(), shape: field.isEmbedded() ? field.getModelRef().getShape(serdes) : null };
+    });
+  }
+
+  shape(data, serdes = (() => { throw new Error('No Sir Sir SerDes!'); }), shape) {
+    shape = shape || this.getShape(serdes);
+
+    return map(data, (doc) => {
+      return shape.reduce((prev, { from, to, shape: subShape }) => {
+        const value = doc[from];
+        if (value === undefined) return prev;
+        return Object.assign(prev, { [to]: subShape ? this.shape(value, serdes, subShape) : value });
+      }, {});
+    });
+  }
+
   validate(query, data) {
     const normalized = this.deserialize(query, data);
 
@@ -150,14 +172,4 @@ module.exports = class extends Model {
       })));
     }));
   }
-
-  tform(query, data) {
-    return map(data, (doc) => {
-      return Object.keys(doc).map(k => this.getField(k)).filter(Boolean).reduce((prev, curr) => {
-        const key = curr.getName();
-        const value = doc[key];
-        return Object.assign(prev, { [key]: curr.tform(query, value) });
-      }, {});
-    });
-  }
 };

package/src/data/stream/DataHydrator.js

@@ -0,0 +1,58 @@
+const { get } = require('lodash');
+const Stream = require('stream');
+const ResultSet = require('./ResultSet');
+const ResultSetItem = require('./ResultSetItemProxy');
+const { promiseChain, mapPromise, toKeyObj } = require('../../service/app.service');
+
+module.exports = class DataHydrator {
+  constructor(query, data) {
+    let { select = {} } = query.toObject();
+    select = toKeyObj(select);
+    return data instanceof Stream ? DataHydrator.stream(query, data, select) : DataHydrator.process(query, data, select);
+  }
+
+  static stream(query, stream, select) {
+    const promises = [];
+
+    return new Promise((resolve, reject) => {
+      stream.on('data', (data) => {
+        promises.push(DataHydrator.hydrate(query, data, select));
+      });
+
+      stream.on('error', reject);
+
+      stream.on('end', () => {
+        Promise.all(promises).then(results => resolve(new ResultSet(query, results)));
+      });
+    });
+  }
+
+  static process(query, data, select) {
+    return mapPromise(data, d => DataHydrator.hydrate(query, d, select)).then(results => new ResultSet(query, results));
+  }
+
+  static hydrate(query, data, select) {
+    const loopArray = Array.from(new Array(Math.max(0, ...Object.keys(select).map(key => key.split('.').length))));
+
+    return new Promise((resolve, reject) => {
+      const item = new ResultSetItem(query, data);
+
+      return Promise.all(Object.keys(select).map((path) => {
+        const arrPath = path.split('.');
+
+        return Promise.all(loopArray.map((el, depth) => {
+          const arr = arrPath.slice(0, depth);
+          const $arr = arr.map(ele => `$${ele}`);
+          const key = arr[depth];
+
+          // id has special handling
+          if (!key || key === 'id') return Promise.resolve();
+
+          // Resolve all other attributes
+          get(item, arr.join('.'));
+          return promiseChain($arr.map($prop => chain => (chain.pop() || item)[$prop]()));
+        }));
+      })).then(() => resolve(item)).catch(e => reject(e));
+    });
+  }
+};

package/src/data/stream/ResultSet.js

@@ -0,0 +1,34 @@
+const { get } = require('lodash');
+const DataService = require('../DataService');
+const { ensureArray } = require('../../service/app.service');
+
+module.exports = class ResultSet {
+  constructor(query, data, adjustForPagination = true) {
+    if (data == null) return data;
+    const { first, after, last, before } = query.toObject();
+
+    let hasNextPage = false;
+    let hasPreviousPage = false;
+    if (adjustForPagination && data.length) (({ hasPreviousPage, hasNextPage } = DataService.paginateResultSet(data, first, after, last, before)));
+
+    return Object.defineProperties(data, {
+      $$pageInfo: {
+        get() {
+          const edges = ensureArray(data);
+
+          return {
+            startCursor: get(edges, '0.$$cursor', ''),
+            endCursor: get(edges, `${edges.length - 1}.$$cursor`, ''),
+            hasPreviousPage,
+            hasNextPage,
+          };
+        },
+        enumerable: false,
+      },
+      $$isResultSet: {
+        value: true,
+        enumerable: false,
+      },
+    });
+  }
+};

package/src/data/stream/ResultSetItem.js

@@ -0,0 +1,158 @@
+const { get } = require('lodash');
+const ResultSet = require('./ResultSet');
+const { map, keyPaths, mapPromise, toGUID, hashObject } = require('../../service/app.service');
+
+module.exports = class ResultSetItem {
+  constructor(query, doc) {
+    if (doc == null) return doc;
+
+    const cache = new Map();
+    const { resolver, model, sort } = query.toObject();
+    const fields = model.getFields().filter(f => f.getName() !== 'id');
+
+    const definition = fields.reduce((prev, field) => {
+      const name = field.getName();
+      const $name = `$${name}`;
+      const value = doc[name];
+
+      // Field attributes
+      prev[name] = {
+        get() {
+          if (cache.has(name)) return cache.get(name);
+          let $value = field.deserialize(query, value);
+
+          if ($value != null && field.isEmbedded()) {
+            const newModel = field.getModelRef();
+            const newQuery = query.model(newModel);
+            const newFields = newModel.getFields().filter(f => f.getName() !== 'id');
+            $value = new ResultSet(newQuery, map($value, v => new ResultSetItem(newQuery, v, newFields)), false);
+          }
+          cache.set(name, $value);
+          return $value;
+        },
+        set($value) {
+          cache.set(name, $value);
+        },
+        enumerable: true,
+        configurable: true, // Allows things like delete
+      };
+
+      // Hydrated field attributes
+      prev[`$${name}`] = {
+        get() {
+          return (args = {}) => {
+            // Ensure where clause
+            args.where = args.where || {};
+
+            // Cache
+            const cacheKey = `${$name}-${hashObject(args)}`;
+            if (cache.has(cacheKey)) return cache.get(cacheKey);
+
+            const promise = new Promise((resolve, reject) => {
+              (() => {
+                const $value = this[name];
+
+                if (field.isScalar() || field.isEmbedded()) return Promise.resolve($value);
+
+                const modelRef = field.getModelRef();
+
+                if (field.isArray()) {
+                  if (field.isVirtual()) {
+                    args.where[[field.getVirtualField()]] = this.id; // Is where[[field.getVirtualField()]] correct?
+                    return resolver.match(modelRef).merge(args).many();
+                  }
+
+                  // Not a "required" query + strip out nulls
+                  args.where.id = $value;
+                  return resolver.match(modelRef).merge(args).many();
+                }
+
+                if (field.isVirtual()) {
+                  args.where[[field.getVirtualField()]] = this.id;
+                  return resolver.match(modelRef).merge(args).one();
+                }
+
+                return resolver.match(modelRef).id($value).one({ required: field.isRequired() });
+              })().then((results) => {
+                if (results == null) return field.resolve(query, results); // Allow field to determine
+                return mapPromise(results, result => field.resolve(query, result)).then(() => results); // Resolve the inside fields but still return "results"!!!!
+              }).then((resolved) => {
+                resolve(resolved);
+              }).catch((e) => {
+                reject(e);
+              });
+            });
+
+            cache.set(cacheKey, promise);
+            return promise;
+          };
+        },
+        enumerable: false,
+      };
+
+      // Field count (let's assume it's a Connection Type - meaning dont try with anything else)
+      prev[`$${name}:count`] = {
+        get() {
+          return (q = {}) => {
+            q.where = q.where || {};
+            if (field.isVirtual()) q.where[field.getVirtualField()] = this.id;
+            else q.where.id = this[name];
+            return resolver.match(field.getModelRef()).merge(q).count();
+          };
+        },
+        enumerable: false,
+      };
+
+      return prev;
+    }, {
+      id: {
+        get() { return doc.id || doc[model.idKey()]; },
+        set(id) { doc.id = id; }, // Embedded array of documents need to set id
+        enumerable: true,
+      },
+
+      $id: {
+        get() { return toGUID(model.getName(), this.id); },
+        enumerable: false,
+      },
+
+      $$cursor: {
+        get() {
+          const sortPaths = keyPaths(sort);
+          const sortValues = sortPaths.reduce((prv, path) => Object.assign(prv, { [path]: get(this, path) }), {});
+          const sortJSON = JSON.stringify(sortValues);
+          return Buffer.from(sortJSON).toString('base64');
+        },
+        enumerable: false,
+      },
+
+      $$model: {
+        value: model,
+        enumerable: false,
+      },
+
+      $$isResultSetItem: {
+        value: true,
+        enumerable: false,
+      },
+
+      $$save: {
+        get() { return input => resolver.match(model).id(this.id).save({ ...this, ...input }); },
+        enumerable: false,
+      },
+
+      $$remove: {
+        get() { return () => resolver.match(model).id(this.id).remove(); },
+        enumerable: false,
+      },
+
+      $$delete: {
+        get() { return () => resolver.match(model).id(this.id).delete(); },
+        enumerable: false,
+      },
+    });
+
+    // Create and return ResultSetItem
+    return Object.defineProperties(this, definition);
+  }
+};