@coderich/autograph 0.9.10 → 0.9.13

package/src/graphql/ast/SchemaDecorator.js

@@ -0,0 +1,138 @@
+const FS = require('fs');
+const Glob = require('glob');
+const Merge = require('deepmerge');
+const { Kind, print, parse, visit } = require('graphql');
+const { mergeASTArray, makeExecutableSchema } = require('../../service/graphql.service');
+const { deleteKeys } = require('../../service/app.service');
+const frameworkExt = require('../extension/framework');
+const typeExt = require('../extension/type');
+const apiExt = require('../extension/api');
+const TypeDefApi = require('./TypeDefApi');
+const Node = require('./Node');
+
+/**
+ * SchemaDecorator
+ *
+ * This class helps facilitate dynamic modification of a schema before it is passed to makeExecutableSchema(). It allows
+ * for "intelligent" merging of schemas and exposes an API wrapper for typeDefs.
+ *
+ * A "schema" is defined by the following object attributes:
+ *
+ *    context <Object> - Globally shared object by all resolvers
+ *    typeDefs <String|Object> - GQL String or AST Object (also supports a mixed array of both)
+ *    resolvers <Object> - GraphQL resolvers
+ *    schemaDirectives <Object> - GraphQL directives
+ *
+ */
+module.exports = class SchemaDecorator extends TypeDefApi {
+  constructor(schema) {
+    super();
+    this.schema = { context: {}, typeDefs: [], resolvers: {}, schemaDirectives: {} };
+    if (schema) this.mergeSchema(schema);
+  }
+
+  /**
+   * Synchronously merge a schema
+   */
+  mergeSchema(schema, options = {}) {
+    // Here we want to normalize the schema into the shape { context, typeDefs, resolvers, schemaDirectives }
+    // We do NOT want to modify the schema object because that may cause unwanted side-effects.
+    const normalizedSchema = { ...schema };
+    if (typeof schema === 'string') normalizedSchema.typeDefs = [schema];
+    else if (schema.typeDefs && !Array.isArray(schema.typeDefs)) normalizedSchema.typeDefs = [schema.typeDefs];
+
+    // For typeDefs we want the AST so that it can be intelligently merged. Here we convert
+    // GQL strings to AST objects and also filter out anything that does not parse to AST.
+    if (normalizedSchema.typeDefs && normalizedSchema.typeDefs.length) {
+      normalizedSchema.typeDefs = deleteKeys(normalizedSchema.typeDefs.map((td) => {
+        try {
+          const ast = typeof td === 'object' ? td : parse(td);
+          return ast.definitions;
+        } catch (e) {
+          return null;
+        }
+      }), ['loc']).filter(Boolean).flat();
+    }
+
+    // Now we're ready to merge the schema
+    const [left, right] = options.passive ? [normalizedSchema, this.schema] : [this.schema, normalizedSchema];
+    if (normalizedSchema.typeDefs && normalizedSchema.typeDefs.length) this.schema.typeDefs = mergeASTArray(left.typeDefs.concat(right.typeDefs));
+    if (normalizedSchema.context) this.schema.context = Merge(left.context, right.context);
+    if (normalizedSchema.resolvers) this.schema.resolvers = Merge(left.resolvers, right.resolvers);
+    if (normalizedSchema.schemaDirectives) this.schema.schemaDirectives = Merge(left.schemaDirectives, right.schemaDirectives);
+
+    // Chaining
+    return this;
+  }
+
+  /**
+   * Asynchronously load files from a given glob pattern and merge each schema
+   */
+  mergeSchemaFromFiles(globPattern, options) {
+    return new Promise((resolve, reject) => {
+      Glob(globPattern, options, (err, files) => {
+        if (err) return reject(err);
+
+        return Promise.all(files.map((file) => {
+          return new Promise((res) => {
+            if (file.endsWith('.js')) res(require(file)); // eslint-disable-line global-require,import/no-dynamic-require
+            else res(FS.readFileSync(file, 'utf8'));
+          }).then(schema => this.mergeSchema(schema, options));
+        })).then(() => resolve(this)).catch(e => reject(e));
+      });
+    });
+  }
+
+  /**
+   * Traverses the current schema's typeDefs in order to keep the TypeDefApi in sync. This operation
+   * only needs to be called when typeDefs have been changed and you want to keep the data model in sync.
+   */
+  initialize() {
+    return super.initialize(this.schema.typeDefs);
+  }
+
+  /**
+   * Decorate the schema with Autograph's default api/definitions
+   */
+  decorate() {
+    this.initialize();
+    this.mergeSchema(frameworkExt(this), { passive: true });
+    this.mergeSchema(typeExt(this), { passive: true });
+    this.initialize();
+    this.mergeSchema(apiExt(this), { passive: true });
+    this.finalize();
+    return this;
+  }
+
+  /**
+   * This should be called once before passing to makeExecutableSchema()
+   */
+  finalize() {
+    const definitions = visit(this.schema.typeDefs, {
+      [Kind.FIELD_DEFINITION]: (node) => {
+        const scope = new Node(node, 'field').getDirectiveArg('field', 'gqlScope', 'crud');
+        if (scope === null || scope.indexOf('r') === -1) return null; // Delete node
+        return false; // Stop traversing this node
+      },
+    });
+
+    this.schema.typeDefs = { kind: Kind.DOCUMENT, definitions };
+    return this;
+  }
+
+  makeExecutableSchema() {
+    return makeExecutableSchema(this.schema);
+  }
+
+  getContext() {
+    return this.schema.context;
+  }
+
+  toObject() {
+    return this.schema;
+  }
+
+  toString() {
+    return print(this.typeDefs);
+  }
+};

package/src/graphql/ast/TypeDefApi.js

@@ -0,0 +1,93 @@
+const { Kind, visit } = require('graphql');
+const Model = require('./Model');
+const Node = require('./Node');
+
+const operations = ['Query', 'Mutation', 'Subscription'];
+const modelKinds = [Kind.OBJECT_TYPE_DEFINITION, Kind.OBJECT_TYPE_EXTENSION, Kind.INTERFACE_TYPE_DEFINITION, Kind.INTERFACE_TYPE_EXTENSION];
+const inputKinds = [Kind.INPUT_OBJECT_TYPE_DEFINITION, Kind.INPUT_OBJECT_TYPE_EXTENSION];
+const scalarKinds = [Kind.SCALAR_TYPE_DEFINITION, Kind.SCALAR_TYPE_EXTENSION];
+const enumKinds = [Kind.ENUM_TYPE_DEFINITION, Kind.ENUM_TYPE_EXTENSION];
+
+module.exports = class TypeDefApi {
+  constructor() {
+    this.models = [];
+    this.scalars = [];
+    this.inputs = [];
+    this.enums = [];
+  }
+
+  initialize(typeDefs) {
+    this.models.length = 0;
+    this.scalars.length = 0;
+    this.inputs.length = 0;
+    this.enums.length = 0;
+
+    visit(typeDefs, {
+      enter: (node) => {
+        if (modelKinds.indexOf(node.kind) > -1 && operations.indexOf(node.name.value) === -1) {
+          this.models.push(new Model(this, node));
+        } else if (scalarKinds.indexOf(node.kind) > -1) {
+          this.scalars.push(new Node(node));
+        } else if (inputKinds.indexOf(node.kind) > -1) {
+          this.inputs.push(new Node(node));
+        } else if (enumKinds.indexOf(node.kind) > -1) {
+          this.enums.push(new Node(node));
+        }
+
+        return false; // Stop traversing this node
+      },
+    });
+
+    return this;
+  }
+
+  // Models
+  getModel(name) {
+    return this.models.find(m => m.getName() === name);
+  }
+
+  getModels() {
+    return this.models;
+  }
+
+  getModelNames() {
+    return this.getModels().map(model => model.getName());
+  }
+
+  getModelMap() {
+    return this.getModels().reduce((prev, model) => Object.assign(prev, { [model.getName()]: model }), {});
+  }
+
+  getMarkedModels() {
+    return Object.values(this.models).filter(model => model.isMarkedModel());
+  }
+
+  getEntityModels() {
+    return Object.values(this.models).filter(model => model.isEntity());
+  }
+
+  // Definitions
+  getInput(name) {
+    return this.getInputs().find(input => input.getName() === name);
+  }
+
+  getInputs() {
+    return this.inputs;
+  }
+
+  getScalar(name) {
+    return this.getScalars().find(scalar => scalar.getName() === name);
+  }
+
+  getScalars() {
+    return this.scalars;
+  }
+
+  getEnum(name) {
+    return this.getEnums().find(el => el.getName() === name);
+  }
+
+  getEnums() {
+    return this.enums;
+  }
+};

package/src/query/Query.js

@@ -251,7 +251,7 @@ module.exports = class Query {
     return {
       isNative: Boolean(this.props.native),
       model: model.getKey(),
-      schema: Query.getSchema(model),
+      shape: model.getShape('deserialize', false),
       method: this.props.method,
       select: this.props.$select,
       joins: this.props.joins,
@@ -292,22 +292,4 @@ module.exports = class Query {
       options: this.props.options,
     };
   }
-
-  static getSchema(model, name = false) {
-    return model.getSelectFields().reduce((prev, field) => {
-      const key = name ? field.getName() : field.getKey();
-      // const modelRef = field.getModelRef();
-      // const isEmbedded = field.isEmbedded();
-
-      return Object.assign(prev, {
-        [key]: {
-          field,
-          alias: name ? field.getKey() : field.getName(),
-          type: field.getDataType(),
-          isArray: field.isArray(),
-          // schema: isEmbedded ? Query.getSchema(modelRef, name) : null,
-        },
-      });
-    }, {});
-  }
 };

package/src/query/QueryResolver.js

@@ -36,7 +36,11 @@ module.exports = class QueryResolver {
     return createSystemEvent('Mutation', { method: 'create', query }, () => {
       const $input = model.serialize(query, model.appendCreateFields(input));
       query.$input($input);
-      return get(flags, 'novalidate') ? this.resolver.resolve(query) : model.validate(query, $input).then(() => this.resolver.resolve(query));
+      const promise = get(flags, 'novalidate') ? this.resolver.resolve(query) : model.validate(query, $input).then(() => this.resolver.resolve(query));
+      return promise.then((doc) => {
+        query.doc(doc);
+        return doc;
+      });
     });
   }
 

package/src/service/app.service.js

@@ -69,6 +69,12 @@ exports.renameObjectKey = (obj, oldKey, newKey) => {
   }
 };
 
+exports.deleteKeys = (obj, keys) => {
+  if (Array.isArray(obj)) obj.map(item => exports.deleteKeys(item, keys));
+  else if (obj === Object(obj)) { keys.forEach(key => delete obj[key]); Object.values(obj).forEach(v => exports.deleteKeys(v, keys)); }
+  return obj;
+};
+
 exports.getDeep = (obj, path, defaultValue) => {
   const [prop, ...rest] = path.split('.');
   const normalize = data => (Array.isArray(data) ? _.flatten(data) : data);
@@ -84,7 +90,7 @@ exports.map = (mixed, fn) => {
   if (mixed == null) return mixed;
   const isArray = Array.isArray(mixed);
   const arr = isArray ? mixed : [mixed];
-  const results = arr.map(el => fn(el));
+  const results = arr.map((...args) => fn(...args));
   return isArray ? results : results[0];
 };
 
@@ -260,3 +266,14 @@ exports.proxyDeep = (obj, handler, proxyMap = new WeakMap(), path = '') => {
 
   return finalProxy;
 };
+
+exports.resolveDataObject = (obj) => {
+  return Promise.all(Object.keys(obj).map(async (key) => {
+    const value = await obj[key];
+    return { key, value };
+  })).then((results) => {
+    return results.reduce((prev, { key, value }) => {
+      return Object.assign(prev, { [key]: value });
+    }, {});
+  });
+};

package/src/service/event.service.js

@@ -56,6 +56,7 @@ exports.createSystemEvent = (name, mixed = {}, thunk = () => {}) => {
     return middleware().then(thunk);
   }).then((result) => {
     event.result = result;
+    if (event.crud === 'create') event.doc = event.query.toObject().doc;
     return systemEvent.emit('system', { type: `post${type}`, data: event }).then((postResult = result) => postResult);
   }).then((result) => {
     if (name === 'Response') return result;

package/src/data/ResultSet3.js

@@ -1,186 +0,0 @@
-const { get } = require('lodash');
-const DataService = require('./DataService');
-const { map, ensureArray, keyPaths, mapPromise, toGUID, hashObject } = require('../service/app.service');
-
-module.exports = class ResultSet {
-  constructor(query, data, adjustForPagination = true) {
-    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;
-
-      const cache = new Map();
-
-      const validKeys = [];
-
-      const definition = {
-        get id() { return doc.id || doc[model.idKey()]; },
-        get $id() { return toGUID(model.getName(), this.id); },
-        get $$data() { return data; },
-        get $$model() { return model; },
-        get $$isResultSetItem() { return true; },
-        get $$save() { return input => resolver.match(model).id(this.id).save({ ...this, ...input }); },
-        get $$remove() { return () => resolver.match(model).id(this.id).remove(); },
-        get $$delete() { return () => resolver.match(model).id(this.id).delete(); },
-        get $$cursor() {
-          return () => {
-            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');
-          };
-        },
-        get toObject() {
-          return () => validKeys.reduce((prev, key) => Object.assign(prev, { [key]: this[key] }), {});
-        },
-      };
-
-      fields.forEach((field) => {
-        const key = field.getKey();
-        const name = field.getName();
-        const $name = `$${name}`;
-        const value = doc[key];
-        validKeys.push(name);
-
-        // Field attributes
-        Object.assign(definition, {
-          get [name]() {
-            let $value = field.deserialize(query, value);
-            $value = $value != null && field.isEmbedded() ? new ResultSet(query.model(field.getModelRef()), $value, false) : $value;
-            return $value;
-          },
-        });
-
-        // Hydrated field attributes
-        Object.assign(definition, {
-          get [$name]() {
-            return (args = {}) => {
-              // Ensure where clause
-              args.where = args.where || {};
-
-              return 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);
-                });
-              });
-            };
-          },
-        });
-
-        // Field count (let's assume it's a Connection Type - meaning dont try with anything else)
-        Object.assign(definition, {
-          get [`${$name}:count`]() {
-            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();
-            };
-          },
-        });
-      });
-
-      // Create and return ResultSetItem
-      const idk = new Proxy(definition, {
-        get(target, prop, rec) {
-          if (cache.has(prop)) return cache.get(prop);
-          const value = Reflect.get(target, prop, rec);
-          if (typeof value === 'function') return value.bind(target);
-          cache.set(prop, value);
-          return value;
-        },
-        set(target, prop, value) {
-          cache.set(prop, value);
-          return true;
-        },
-        ownKeys() {
-          return validKeys;
-        },
-        getOwnPropertyDescriptor(target, prop) {
-          if (validKeys.indexOf(prop) === -1) {
-            return {
-              writable: true,
-              enumerable: true,
-              configurable: true,
-            };
-          }
-
-          return {
-            writable: false,
-            enumerable: false,
-            configurable: false,
-          };
-        },
-      });
-
-      // console.log(idk);
-      // // console.log(idk.toObject());
-      return idk;
-    });
-
-    let hasNextPage = false;
-    let hasPreviousPage = false;
-    if (adjustForPagination && rs.length) (({ hasPreviousPage, hasNextPage } = DataService.paginateResultSet(rs, first, after, last, before)));
-
-    return Object.defineProperties(rs, {
-      $$pageInfo: {
-        get() {
-          const edges = ensureArray(rs);
-
-          return {
-            startCursor: get(edges, '0.$$cursor', ''),
-            endCursor: get(edges, `${edges.length - 1}.$$cursor`, ''),
-            hasPreviousPage,
-            hasNextPage,
-          };
-        },
-        enumerable: false,
-      },
-      $$isResultSet: {
-        value: true,
-        enumerable: false,
-      },
-      toObject: {
-        get() {
-          return () => map(this, doc => Object.entries(doc).reduce((prev, [key, value]) => {
-            if (value === undefined) return prev;
-            prev[key] = get(value, '$$isResultSet') ? value.toObject() : value;
-            return prev;
-          }, {}));
-        },
-        enumerable: false,
-        configurable: true,
-      },
-    });
-  }
-};