@coderich/autograph 0.9.11 → 0.9.12

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.12",
   "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/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/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');

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));
+    this.mergeSchema(typeExt(this));
+    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/graphql/core/Field.js

@@ -0,0 +1,20 @@
+const { Kind, visit } = require('graphql');
+const Node = require('./Node');
+
+module.exports = class Field extends Node {
+  constructor(ast) {
+    super(ast);
+    // this.fields = {};
+    // if (ast) this.appendAST(ast);
+  }
+
+  appendAST(ast) {
+    // visit(ast, {
+    //   [Kind.FIELD_DEFINITION]: (node) => {
+    //     const name = node.name.value;
+    //     if (this.fields[name]) this.fields[name].appendAST(node);
+    //     else this.fields[name] = new Field(node);
+    //   },
+    // });
+  }
+};

package/src/graphql/core/GraphQL.js

@@ -0,0 +1,21 @@
+const { graphql, execute, validate } = require('graphql');
+const Schema = require('./Schema');
+
+module.exports = class GraphQL {
+  constructor(schema) {
+    this.schema = (schema instanceof Schema ? schema : new Schema(schema)).makeExecutableSchema();
+  }
+
+  exec(source, variableValues) {
+    const { schema } = this.schema;
+    return graphql({ schema, source, variableValues, contextValue: schema.context });
+  }
+
+  execute(source, variableValues) {
+
+  }
+
+  validate(source, variableValues) {
+
+  }
+};

package/src/graphql/core/Model.js

@@ -0,0 +1,23 @@
+const { Kind, visit } = require('graphql');
+const Field = require('./Field');
+const Node = require('./Node');
+
+module.exports = class Model extends Node {
+  constructor(ast) {
+    super(ast);
+    this.fields = {};
+    if (ast) this.appendAST(ast);
+  }
+
+  appendAST(ast) {
+    visit(ast, {
+      [Kind.FIELD_DEFINITION]: (node) => {
+        const name = node.name.value;
+        if (this.fields[name]) this.fields[name].appendAST(node);
+        else this.fields[name] = new Field(node);
+      },
+    });
+
+    return this;
+  }
+};

package/src/graphql/core/Node.js

@@ -0,0 +1,34 @@
+const { Kind } = require('graphql');
+
+module.exports = class Node {
+  constructor(ast) {
+    this.ast = ast;
+  }
+
+  getKind() {
+    return this.ast.kind;
+  }
+
+  getName() {
+    return this.ast.name.value;
+  }
+
+  getValue(ast = this.ast) {
+    const { value = {} } = ast;
+
+    switch (value.kind) {
+      case Kind.NULL: return null;
+      case Kind.LIST: return value.values.map(el => this.getValue({ value: el }));
+      case Kind.OBJECT: {
+        return value.fields.reduce((prev, field) => {
+          const node = new Node(field);
+          return Object.assign(prev, { [node.getName()]: node.getValue() });
+        }, {});
+      }
+      default: {
+        if (ast.values) return ast.values.map(v => v.name.value);
+        return value.value;
+      }
+    }
+  }
+};

package/src/graphql/core/Schema.js

@@ -0,0 +1,63 @@
+const FS = require('fs');
+const Glob = require('glob');
+const Merge = require('deepmerge');
+const { Kind, parse, visit, printSchema, buildSchema } = require('graphql');
+const { makeExecutableSchema } = require('graphql-tools');
+const Model = require('./Model');
+
+const modelKinds = [Kind.OBJECT_TYPE_DEFINITION, Kind.OBJECT_TYPE_EXTENSION, Kind.INTERFACE_TYPE_DEFINITION, Kind.INTERFACE_TYPE_EXTENSION];
+
+module.exports = class Schema {
+  constructor(schema) {
+    this.models = {};
+    this.schema = { typeDefs: [], context: {}, resolvers: {}, schemaDirectives: {} };
+    if (schema) this.appendSchema(schema);
+  }
+
+  appendSchema(schema) {
+    // Normalize schema
+    if (typeof schema === 'string') schema = { typeDefs: [schema] };
+    else if (schema.typeDefs && !Array.isArray(schema.typeDefs)) schema.typeDefs = [schema.typeDefs];
+
+    // Merge schema
+    this.schema = Merge(this.schema, schema);
+
+    // Visit AST to maintain model definitions
+    if (schema.typeDefs) {
+      visit(parse(schema.typeDefs.join('\n')), {
+        enter: (node) => {
+          if (modelKinds.indexOf(node.kind) > -1) {
+            const name = node.name.value;
+            if (this.models[name]) this.models[name].appendAST(node);
+            else this.models[name] = new Model(node);
+          }
+        },
+      });
+    }
+
+    return this;
+  }
+
+  appendSchemaFromFile(file) {
+    if (file.endsWith('.js')) this.appendSchema(require(file)); // eslint-disable-line global-require,import/no-dynamic-require
+    else this.appendSchema(FS.readFileSync(file, 'utf8'));
+    return this;
+  }
+
+  appendSchemaFromDirectory(dir, options) {
+    Glob.sync(`${dir}/**/*.{js,gql,graphql}`, options).forEach(file => this.appendSchemaFromFile(file));
+    return this;
+  }
+
+  makeExecutableSchema() {
+    return makeExecutableSchema(this.schema);
+  }
+
+  printSchema() {
+    return printSchema(buildSchema(this.toString()));
+  }
+
+  toString() {
+    return this.schema.typeDefs.join('\n');
+  }
+};

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);

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;