@coderich/autograph 0.9.11 → 0.9.14

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.11",
+  "version": "0.9.14",
   "description": "AutoGraph",
   "keywords": [
     "graphql",
@@ -30,6 +30,7 @@
     "ratchet": "ratchet"
   },
   "dependencies": {
+    "@graphql-tools/schema": "^8.3.14",
     "@hapi/boom": "^9.1.0",
     "axios": "^0.21.4",
     "dataloader": "^2.0.0",
@@ -54,6 +55,9 @@
     "redis": "^2.8.0",
     "redis-mock": "^0.47.0"
   },
+  "peerDependencies": {
+    "graphql": ">15"
+  },
   "repository": {
     "type": "git",
     "url": "git@github.com:coderich/autograph.git"

package/src/core/Resolver.js

@@ -1,3 +1,4 @@
+const { isEmpty } = require('lodash');
 const Model = require('../data/Model');
 const Query = require('../query/Query');
 const ResultSet = require('../data/ResultSet');
@@ -89,7 +90,7 @@ module.exports = class Resolver {
         // 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);
+        if (Object.prototype.hasOwnProperty.call(where, key) && isEmpty(where[key])) return Promise.resolve(method === 'findMany' ? [] : null);
 
         //
         return this.loaders.get(`${model}`).load(query);

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/data/Field.js

@@ -2,7 +2,7 @@ const Type = require('./Type');
 const Field = require('../graphql/ast/Field');
 const Rule = require('../core/Rule');
 const Transformer = require('../core/Transformer');
-const { map, uvl, isPlainObject, ensureArray, promiseChain } = require('../service/app.service');
+const { map, uvl, isPlainObject, ensureArray } = require('../service/app.service');
 
 module.exports = class extends Field {
   constructor(model, field) {
@@ -63,17 +63,6 @@ module.exports = class extends Field {
     return transformers.concat(this.type.getDeserializers());
   }
 
-  getResolvers() {
-    const resolvers = [];
-
-    Object.entries(this.getDirectiveArgs('field', {})).forEach(([key, value]) => {
-      if (!Array.isArray(value)) value = [value];
-      if (key === 'resolve') resolvers.push(...value.map(t => Transformer.getInstances()[t]));
-    });
-
-    return resolvers.concat(this.type.getResolvers());
-  }
-
   validate(query, value) {
     const modelRef = this.getModelRef();
     const rules = [...this.getRules()];
@@ -124,20 +113,6 @@ module.exports = class extends Field {
     return this.transform(query, value, 'deserialize');
   }
 
-  /**
-   * Applies any user-defined @field(resolve: [...methods]) in series
-   * This is ONLY run when resolving a value via the $<name> attribute
-   */
-  resolve(query, value) {
-    const resolvers = [...this.getResolvers()];
-
-    return promiseChain(resolvers.map(fn => (chain) => {
-      return Promise.resolve(fn(this, uvl(this.cast(chain.pop()), value), query));
-    })).then((results) => {
-      return uvl(this.cast(results.pop()), value);
-    });
-  }
-
   tform(query, value) {
     // Determine transformers
     const transformers = this.getTransformers();

package/src/data/Model.js

@@ -160,4 +160,24 @@ module.exports = class extends Model {
       }, {});
     });
   }
+
+  getShape(serdes = 'deserialize', recursive = true) {
+    return this.getSelectFields().map((field) => {
+      const [from, to] = serdes === 'serialize' ? [field.getName(), field.getKey()] : [field.getKey(), field.getName()];
+      const shape = recursive && field.isEmbedded() ? field.getModelRef().getShape(serdes, recursive) : null;
+      return { from, to, type: field.getDataType(), isArray: field.isArray(), shape };
+    });
+  }
+
+  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 });
+      }, {});
+    });
+  }
 };

package/src/data/ResultSet.js

@@ -1,170 +1,51 @@
 const { get } = require('lodash');
 const DataService = require('./DataService');
-const { map, ensureArray, keyPaths, mapPromise, toGUID, hashObject } = require('../service/app.service');
+const { map, ensureArray, keyPaths, toGUID } = require('../service/app.service');
+
+const modelCache = new WeakMap();
 
 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');
 
-    const rs = map(data, (doc) => {
-      if (doc == null || typeof doc !== 'object') return doc;
+    ResultSet.ensureModelCache(model);
 
-      //
-      const cache = new Map();
-
-      const definition = fields.reduce((prev, field) => {
-        const key = field.getKey();
-        const name = field.getName();
-        const $name = `$${name}`;
-        const value = doc[key];
-
-        // Field attributes
-        prev[name] = {
-          get() {
-            if (cache.has(name)) return cache.get(name);
-            let $value = field.deserialize(query, value);
-            $value = $value != null && field.isEmbedded() ? new ResultSet(query.model(field.getModelRef()), $value, false) : $value;
-            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,
-        },
+    const { template, fieldDefs } = modelCache.get(model);
 
-        $id: {
-          get() { return toGUID(model.getName(), this.id); },
-          enumerable: false,
-        },
+    const rs = map(data, (doc) => {
+      if (doc == null || typeof doc !== 'object') return doc;
 
-        $$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');
+      const instance = Object.create(template, {
+        $$services: {
+          value: {
+            cache: new Map(),
+            data: doc,
+            resolver,
+            query,
+            sort,
           },
           enumerable: false,
         },
+      });
 
-        $$model: {
-          value: model,
-          enumerable: false,
+      return new Proxy(instance, {
+        ownKeys(target) {
+          return Reflect.ownKeys(target).concat('id', fieldDefs.map(d => d.name));
         },
-
-        $$isResultSetItem: {
-          value: true,
-          enumerable: false,
+        getOwnPropertyDescriptor(target, prop) {
+          return (prop === 'id' || fieldDefs.find(el => el.name === prop)) ? { enumerable: true, configurable: true } : Reflect.getOwnPropertyDescriptor(target, prop);
         },
-
-        $$save: {
-          get() { return input => resolver.match(model).id(this.id).save({ ...this, ...input }); },
-          enumerable: false,
+        getPrototypeOf() {
+          return { $$services: instance.$$services };
         },
-
-        $$remove: {
-          get() { return () => resolver.match(model).id(this.id).remove(); },
-          enumerable: false,
-        },
-
-        $$delete: {
-          get() { return () => resolver.match(model).id(this.id).delete(); },
-          enumerable: false,
-        },
-
-        toObject: {
-          get() {
-            return () => map(this, obj => Object.entries(obj).reduce((prev, [key, value]) => {
-              if (value === undefined) return prev;
-              prev[key] = get(value, '$$isResultSet') ? value.toObject() : value;
-              return prev;
-            }, {}));
-          },
-          enumerable: false,
-          configurable: true,
+        deleteProperty(target, prop) {
+          const { key = prop } = fieldDefs.find(d => d.name === prop);
+          delete instance[prop];
+          delete instance.$$services.data[key];
         },
       });
-
-      // Create and return ResultSetItem
-      return Object.defineProperties({}, definition);
     });
 
     let hasNextPage = false;
@@ -202,4 +83,164 @@ module.exports = class ResultSet {
       },
     });
   }
+
+  static ensureModelCache(model) {
+    if (!modelCache.has(model)) {
+      const fields = model.getFields().filter(f => f.getName() !== 'id');
+
+      const fieldDefs = fields.map(field => ({
+        field,
+        key: field.getKey(),
+        name: field.getName(),
+        isArray: field.isArray(),
+        isScalar: field.isScalar(),
+        isVirtual: field.isVirtual(),
+        isRequired: field.isRequired(),
+        isEmbedded: field.isEmbedded(),
+        modelRef: field.getModelRef(),
+        virtualField: field.getVirtualField(),
+        // deserialize: field.deserialize.bind(field),
+        // fieldResolve: field.resolve.bind(field),
+        get useDefaultResolver() { return Boolean(this.isScalar || this.isEmbedded); },
+      }));
+
+      const template = ResultSet.makeModelTemplate(model, fieldDefs);
+
+      modelCache.set(model, { template, fieldDefs });
+    }
+  }
+
+  static makeModelTemplate(model, fieldDefs) {
+    const definition = fieldDefs.reduce((prev, fieldDef) => {
+      const { field, key, name, isArray, isVirtual, isRequired, isEmbedded, modelRef, virtualField, useDefaultResolver } = fieldDef;
+      const $name = `$${name}`;
+
+      // Deserialized field attributes
+      prev[name] = {
+        get() {
+          if (this.$$services.cache.has(name)) return this.$$services.cache.get(name);
+          let $value = field.deserialize(this.$$services.query, this.$$services.data[key]);
+          if ($value != null && isEmbedded) $value = new ResultSet(this.$$services.query.model(modelRef), $value, false);
+          this.$$services.cache.set(name, $value);
+          return $value;
+        },
+        set($value) {
+          this.$$services.cache.set(name, $value);
+        },
+        enumerable: true,
+        configurable: true, // Allows things like delete
+      };
+
+      // Fully deserialized, hydrated, and resolved field attributes
+      prev[$name] = {
+        get() {
+          return (args = {}) => {
+            // Grab deserialized value
+            const $value = this[name];
+
+            // Default resolver return immediately!
+            if (useDefaultResolver) return $value;
+
+            // Ensure where clause for DB lookup
+            args.where = args.where || {};
+
+            if (isArray) {
+              if (isVirtual) {
+                args.where[[virtualField]] = this.id; // Is where[[virtualField]] correct?
+                return this.$$services.resolver.match(modelRef).merge(args).many();
+              }
+
+              // Not a "required" query + strip out nulls
+              args.where.id = $value;
+              return this.$$services.resolver.match(modelRef).merge(args).many();
+            }
+
+            if (isVirtual) {
+              args.where[[virtualField]] = this.id;
+              return this.$$services.resolver.match(modelRef).merge(args).one();
+            }
+
+            return this.$$services.resolver.match(modelRef).id($value).one({ required: isRequired });
+          };
+        },
+        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 (isVirtual) q.where[virtualField] = this.id;
+            else q.where.id = this[name];
+            return this.$$services.resolver.match(modelRef).merge(q).count();
+          };
+        },
+        enumerable: false,
+      };
+
+      return prev;
+    }, {
+      id: {
+        get() { return this.$$services.data.id || this.$$services.data[model.idKey()]; },
+        set(id) { this.$$services.data.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(this.$$services.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 => this.$$services.resolver.match(model).id(this.id).save({ ...this, ...input }); },
+        enumerable: false,
+      },
+
+      $$remove: {
+        get() { return () => this.$$services.resolver.match(model).id(this.id).remove(); },
+        enumerable: false,
+      },
+
+      $$delete: {
+        get() { return () => this.$$services.resolver.match(model).id(this.id).delete(); },
+        enumerable: false,
+      },
+
+      toObject: {
+        get() {
+          return () => map(this, obj => Object.entries(obj).reduce((prev, [key, value]) => {
+            if (value === undefined) return prev;
+            prev[key] = get(value, '$$isResultSet') ? value.toObject() : value;
+            return prev;
+          }, {}));
+        },
+        enumerable: false,
+        configurable: true,
+      },
+    });
+
+    // return Object.defineProperties({}, definition);
+    return Object.create(null, definition);
+  }
 };

package/src/data/Type.js

@@ -69,18 +69,4 @@ module.exports = class extends Type {
 
     return transformers;
   }
-
-  getResolvers() {
-    const resolvers = [];
-    const scalarType = this.field.getScalarRef();
-
-    if (scalarType) {
-      Object.entries(scalarType.getDirectiveArgs('field', {})).forEach(([key, value]) => {
-        if (!Array.isArray(value)) value = [value];
-        if (key === 'resolve') resolvers.push(...value.map(t => Transformer.getInstances()[t]));
-      });
-    }
-
-    return resolvers;
-  }
 };

package/src/driver/MongoDriver.js

@@ -1,3 +1,4 @@
+const Util = require('util');
 const { get, has } = require('lodash');
 const { MongoClient, ObjectID } = require('mongodb');
 const { proxyDeep, toKeyObj, globToRegex, proxyPromise, isScalarDataType, promiseRetry } = require('../service/app.service');
@@ -25,7 +26,7 @@ module.exports = class MongoDriver {
   }
 
   query(collection, method, ...args) {
-    if (has(args[args.length - 1], 'debug')) console.log(collection, method, JSON.stringify(args));
+    if (has(args[args.length - 1], 'debug')) console.log(collection, method, Util.inspect(args, { depth: null, showHidden: false, colors: true }));
     return this.raw(collection)[method](...args);
   }
 
@@ -148,15 +149,15 @@ module.exports = class MongoDriver {
   }
 
   static getAddFields(query) {
-    const { schema, where } = query;
+    const { shape, where } = query;
 
-    return Object.entries(schema).reduce((prev, [key, { type }]) => {
-      const value = where[key];
+    return shape.reduce((prev, { from, type }) => {
+      const value = where[from];
       if (value === undefined) return prev;
       if (!isScalarDataType(type)) return prev;
       const stype = String((type === 'Float' || type === 'Int' ? 'Number' : type)).toLowerCase();
       if (String(typeof value) === `${stype}`) return prev;
-      return Object.assign(prev, { [key]: { $toString: `$${key}` } });
+      return Object.assign(prev, { [from]: { $toString: `$${from}` } });
     }, {});
   }
 

package/src/graphql/ast/Model.js

@@ -12,6 +12,10 @@ module.exports = class Model extends Node {
     this.key = uvl(this.getDirectiveArg('model', 'key'), this.getName());
   }
 
+  idKey() {
+    return this.getDirectiveArg('model', 'id', '_id');
+  }
+
   getSchema() {
     return this.schema;
   }

package/src/graphql/ast/Schema.js

@@ -1,6 +1,5 @@
 const FS = require('fs');
 const Glob = require('glob');
-const Path = require('path');
 const Merge = require('deepmerge');
 const { nvl, uvl } = require('../../service/app.service');
 const { validateSchema, makeExecutableSchema, mergeASTSchema, mergeASTArray } = require('../../service/graphql.service');