@coderich/autograph 0.10.0 → 0.10.1

package/src/data/Type.js

@@ -1,6 +1,5 @@
 const Type = require('../graphql/ast/Type');
-const Rule = require('../core/Rule');
-const Transformer = require('../core/Transformer');
+const Pipeline = require('./Pipeline');
 
 module.exports = class extends Type {
   constructor(field) {
@@ -8,79 +7,25 @@ module.exports = class extends Type {
     this.field = field;
   }
 
-  getRules() {
-    const rules = [];
-    const scalarType = this.field.getScalarRef();
+  getStructures() {
+    const type = this.field.getType();
     const enumType = this.field.getEnumRef();
-
-    if (scalarType) {
-      Object.entries(scalarType.getDirectiveArgs('field', {})).forEach(([key, value]) => {
-        if (!Array.isArray(value)) value = [value];
-        if (key === 'enforce') rules.push(...value.map(r => Rule.getInstances()[r]));
-      });
-    }
-
-    if (enumType) {
-      const values = enumType.getValue();
-      rules.push(Rule.allow(...values));
-    }
-
-    return rules;
-  }
-
-  getTransformers() {
-    const transformers = [];
     const scalarType = this.field.getScalarRef();
-
-    if (scalarType) {
-      Object.entries(scalarType.getDirectiveArgs('field', {})).forEach(([key, value]) => {
-        if (!Array.isArray(value)) value = [value];
-        if (key === 'transform') transformers.push(...value.map(t => Transformer.getInstances()[t]));
-      });
-    }
-
-    return transformers;
-  }
-
-  getSerializers() {
-    const transformers = [];
-    const scalarType = this.field.getScalarRef();
-
-    if (scalarType) {
-      Object.entries(scalarType.getDirectiveArgs('field', {})).forEach(([key, value]) => {
-        if (!Array.isArray(value)) value = [value];
-        if (key === 'serialize') transformers.push(...value.map(t => Transformer.getInstances()[t]));
-      });
-    }
-
-    return transformers;
-  }
-
-  getDeserializers() {
-    const transformers = [];
-    const scalarType = this.field.getScalarRef();
-
-    if (scalarType) {
-      Object.entries(scalarType.getDirectiveArgs('field', {})).forEach(([key, value]) => {
-        if (!Array.isArray(value)) value = [value];
-        if (key === 'deserialize') transformers.push(...value.map(t => Transformer.getInstances()[t]));
-      });
-    }
-
-    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;
+    const structures = { instructs: [], restructs: [], destructs: [], constructs: [], $serializers: [], serializers: [], $deserializers: [], deserializers: [], transformers: [] };
+
+    if (enumType) structures.serializers.push(Pipeline.define(`$allow:${type}`, Pipeline.allow(...enumType.getValue()), { configurable: true }));
+    if (!scalarType) return structures;
+
+    return Object.entries(scalarType.getDirectiveArgs('field', {})).reduce((prev, [key, value]) => {
+      if (!Array.isArray(value)) value = [value];
+      if (key === 'instruct') prev.instructs.push(...value.map(t => Pipeline[t]));
+      if (key === 'restruct') prev.restructs.push(...value.map(t => Pipeline[t]));
+      if (key === 'destruct') prev.destructs.push(...value.map(t => Pipeline[t]));
+      if (key === 'construct') prev.constructs.push(...value.map(t => Pipeline[t]));
+      if (key === 'serialize') prev.serializers.push(...value.map(t => Pipeline[t]));
+      if (key === 'deserialize') prev.deserializers.push(...value.map(t => Pipeline[t]));
+      if (key === 'transform') prev.transformers.push(...value.map(t => Pipeline[t]));
+      return prev;
+    }, structures);
   }
 };

package/src/driver/MongoDriver.js

@@ -1,6 +1,7 @@
-const { get, has } = require('lodash');
+const Util = require('util');
+const { get } = require('lodash');
 const { MongoClient, ObjectID } = require('mongodb');
-const { proxyDeep, toKeyObj, globToRegex, proxyPromise, isScalarDataType, promiseRetry } = require('../service/app.service');
+const { map, ensureArray, proxyDeep, toKeyObj, globToRegex, proxyPromise, isScalarDataType, promiseRetry } = require('../service/app.service');
 
 module.exports = class MongoDriver {
   constructor(config) {
@@ -24,7 +25,7 @@ module.exports = class MongoDriver {
   }
 
   query(collection, method, ...args) {
-    if (has(args[args.length - 1], 'debug')) console.log(collection, method, JSON.stringify(args, null, 2));
+    if (get(args[args.length - 1], 'debug') === true) console.log(collection, method, Util.inspect(args, { depth: null, showHidden: false, colors: true }));
     if (method === 'aggregate') args.splice(2);
     return this.raw(collection)[method](...args);
   }
@@ -48,10 +49,7 @@ module.exports = class MongoDriver {
   findMany(query) {
     const { model, options = {}, flags } = query;
     Object.assign(options, this.config.query || {});
-
-    return this.query(model, 'aggregate', MongoDriver.aggregateQuery(query), options, flags).then((cursor) => {
-      return cursor.stream();
-    });
+    return this.query(model, 'aggregate', MongoDriver.aggregateQuery(query), options, flags).then(cursor => cursor.stream());
   }
 
   count(query) {
@@ -142,10 +140,10 @@ module.exports = class MongoDriver {
     return proxyDeep(toKeyObj(where), {
       get(target, prop, rec) {
         const value = Reflect.get(target, prop, rec);
-        if (Array.isArray(value)) return { $in: value };
         if (typeof value === 'function') return value.bind(target);
-        if (typeof value === 'string') { return globToRegex(value, { nocase: true, regex: true }); }
-        return value;
+        const $value = map(value, v => (typeof v === 'string' ? globToRegex(v, { nocase: true, regex: true }) : v));
+        if (Array.isArray($value)) return { $in: $value };
+        return $value;
       },
     }).toObject();
   }
@@ -153,13 +151,17 @@ module.exports = class MongoDriver {
   static getAddFields(query) {
     const { shape, where } = query;
 
-    return shape.reduce((prev, { from, type }) => {
-      const value = where[from];
+    return shape.reduce((prev, { from, type, isArray }) => {
+      // Basic checks to see if worth converting for regex
+      let 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, { [from]: { $toString: `$${from}` } });
+
+      // Do regex conversion
+      if (isArray) value = value.$in || value; // Where clause does not always use $in
+      if (!ensureArray(value).some(el => el instanceof RegExp)) return prev;
+      const conversion = isArray ? { $map: { input: `$${from}`, as: 'el', in: { $toString: '$$el' } } } : { $toString: `$${from}` };
+      return Object.assign(prev, { [from]: conversion });
     }, {});
   }
 
@@ -182,7 +184,7 @@ module.exports = class MongoDriver {
   }
 
   static aggregateQuery(query, count = false) {
-    const { where: $match, sort = {}, skip, limit, joins, shape, after, before, first } = query;
+    const { where: $match, sort = {}, skip, limit, joins, after, before, first } = query;
     const $aggregate = [{ $match }];
 
     // Used for $regex matching
@@ -215,9 +217,9 @@ module.exports = class MongoDriver {
       if (before) $aggregate.push({ $match: { $or: Object.entries(before).reduce((prev, [key, value]) => prev.concat({ [key]: { [sort[key] === 1 ? '$lte' : '$gte']: value } }), []) } });
       if (first) $aggregate.push({ $limit: first });
 
-      // Projection
-      const $project = MongoDriver.getProjectFields(shape);
-      $aggregate.push({ $project });
+      // // Projection
+      // const $project = MongoDriver.getProjectFields(shape);
+      // $aggregate.push({ $project });
     }
 
     return $aggregate;

package/src/graphql/ast/Field.js

@@ -1,4 +1,3 @@
-const { get } = require('lodash');
 const Node = require('./Node');
 const Type = require('./Type');
 const { uvl } = require('../../service/app.service');
@@ -44,27 +43,6 @@ module.exports = class Field extends Node {
     return this.getDirectiveArg('field', 'default');
   }
 
-  resolveBoundValue(query, initialValue) {
-    // If no bound value, return default value
-    const defaultValue = uvl(initialValue, this.getDefaultValue());
-    if (!this.hasBoundValue()) return defaultValue;
-
-    // Grab @value definition, if passive then check for initialValue
-    const { scope, path, passive = false } = this.getDirectiveArgs('value');
-    if (passive && initialValue !== undefined) return initialValue;
-
-    // Resolve @value
-    switch (scope) {
-      case 'context': {
-        const { resolver } = query.toObject();
-        const context = resolver.getContext();
-        const value = get(context, path);
-        return uvl((typeof value === 'function') ? value() : value, defaultValue);
-      }
-      default: return this[path];
-    }
-  }
-
   // Model Methods
   getSchema() {
     return this.model.getSchema();
@@ -75,7 +53,8 @@ module.exports = class Field extends Node {
   }
 
   getModelRef() {
-    return this.schema.getModel(this.getType());
+    const refType = this.getDirectiveArg('field', 'id', this.getType());
+    return this.schema.getModel(refType);
   }
 
   getFieldRef() {
@@ -90,6 +69,10 @@ module.exports = class Field extends Node {
     return model ? model.getField(this.getVirtualRef()) : null;
   }
 
+  getIdModel() {
+    return this.getModelRef() || this.getModel();
+  }
+
   resolveField() {
     const field = this.getVirtualField() || this;
     return field === this ? this : field.resolveField();
@@ -101,7 +84,7 @@ module.exports = class Field extends Node {
   }
 
   isDefaulted() {
-    return Boolean(this.hasBoundValue() || this.getDefaultValue() != null);
+    return Boolean(this.getDefaultValue() != null);
   }
 
   isRequired() {
@@ -117,6 +100,16 @@ module.exports = class Field extends Node {
     return Boolean(modelRef && !this.isEmbedded());
   }
 
+  isIdField() {
+    return this.isPrimaryKeyId() || this.isFKReference();
+  }
+
+  isPrimaryKeyId() {
+    const key = this.getKey();
+    const idKey = this.getModel().idKey();
+    return key === idKey;
+  }
+
   getJoinInfo() {
     const modelRef = this.getModelRef();
     if (!modelRef || this.isEmbedded()) return null;
@@ -179,4 +172,30 @@ module.exports = class Field extends Node {
     if (this.isFKReference()) return this.isArray() ? '[ID]' : 'ID';
     return this.getGQLType();
   }
+
+  initialize() {
+    this.props = {
+      name: this.getName(),
+      type: this.getType(),
+      datatype: this.getDataType(),
+      defaultValue: this.getDefaultValue(),
+      isArray: this.isArray(),
+      isScalar: this.isScalar(),
+      isVirtual: this.isVirtual(),
+      isRequired: this.isRequired(),
+      isEmbedded: this.isEmbedded(),
+      isIdField: this.isIdField(),
+      isPrimaryKeyId: this.isPrimaryKeyId(),
+      isPersistable: this.isPersistable(),
+      modelRef: this.getModelRef(),
+      virtualRef: this.getVirtualRef(),
+      virtualField: this.getVirtualField(),
+    };
+
+    return this;
+  }
+
+  toObject() {
+    return this.props;
+  }
 };

package/src/graphql/ast/Model.js

@@ -92,10 +92,6 @@ module.exports = class Model extends Node {
     return this.getFields().filter(field => field.isDefaulted());
   }
 
-  getBoundValueFields() {
-    return this.getFields().filter(field => field.hasBoundValue());
-  }
-
   getDataRefFields() {
     return this.getFields().filter(field => Boolean(field.getDataRef()));
   }
@@ -104,10 +100,6 @@ module.exports = class Model extends Node {
     return this.getFields().filter(field => Boolean(field.getModelRef()));
   }
 
-  // getDataRefFields() {
-  //   return this.fields.filter(field => Boolean(field.getDataRef() && !field.isEmbedded()));
-  // }
-
   getEmbeddedFields() {
     return this.getFields().filter(field => field.isEmbedded());
   }
@@ -128,14 +120,6 @@ module.exports = class Model extends Node {
     return this.getFields().filter(field => field.isPersistable());
   }
 
-  getSerializeFields() {
-    return this.getFields().filter(field => field.getSerializers().length);
-  }
-
-  getDeserializeFields() {
-    return this.getFields().filter(field => field.getDeserializers().length);
-  }
-
   // Misc
   getIndexes() {
     return this.getDirectives('index').map((d) => {
@@ -153,4 +137,9 @@ module.exports = class Model extends Node {
       }, {});
     });
   }
+
+  initialize() {
+    this.fields.forEach(field => field.initialize());
+    return this;
+  }
 };

package/src/graphql/ast/Node.js

@@ -2,7 +2,6 @@ const { get } = require('lodash');
 const { Kind } = require('graphql');
 const { nvl, uvl } = require('../../service/app.service');
 const { mergeAST } = require('../../service/graphql.service');
-// const Memoizer = require('../../data/Memoizer');
 
 const operations = ['Query', 'Mutation', 'Subscription'];
 const modelKinds = [Kind.OBJECT_TYPE_DEFINITION, Kind.OBJECT_TYPE_EXTENSION, Kind.INTERFACE_TYPE_DEFINITION, Kind.INTERFACE_TYPE_EXTENSION];
@@ -18,7 +17,6 @@ module.exports = class Node {
     this.toString = () => this.getName();
     this.nodeType = nodeType;
     this.name = get(this.ast, 'name.value');
-    // return new Memoizer(this, Object.getOwnPropertyNames(Node.prototype).filter(m => ['getContext'].indexOf(m) === -1));
   }
 
   // Basic AST Methods
@@ -130,14 +128,6 @@ module.exports = class Node {
     return this.getDirectiveArg('model', 'meta');
   }
 
-  getSerialize() {
-    return this.getDirectiveArg('field', 'serialize', this.getDirectiveArg('model', 'serialize'));
-  }
-
-  getDeserialize() {
-    return this.getDirectiveArg('field', 'deserialize', this.getDirectiveArg('model', 'deserialize'));
-  }
-
   // Booleans
   isModel() {
     return Boolean(modelKinds.some(k => this.getKind() === k) && operations.every(o => this.getName() !== o));
@@ -166,13 +156,6 @@ module.exports = class Node {
     return Boolean(this.getDirectiveArg('link', 'by'));
   }
 
-  /**
-   * Does the model/field have a bound @value directive
-   */
-  hasBoundValue() {
-    return Boolean(this.getDirective('value'));
-  }
-
   /**
    * Is a model annotated with @model
    */
@@ -208,14 +191,6 @@ module.exports = class Node {
     }
   }
 
-  /**
-   * Can the field be changed after it's set
-   */
-  isImmutable() {
-    const enforce = this.getDirectiveArg('field', 'enforce', '');
-    return Boolean(JSON.stringify(enforce).indexOf('immutable') > -1);
-  }
-
   /**
    * Define it's behavior at the Data Access Layer
    *

package/src/graphql/ast/Schema.js

@@ -1,141 +1,137 @@
 const FS = require('fs');
 const Glob = require('glob');
 const Merge = require('deepmerge');
-const { nvl, uvl } = require('../../service/app.service');
-const { validateSchema, makeExecutableSchema, mergeASTSchema, mergeASTArray } = require('../../service/graphql.service');
+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');
-const Model = require('./Model');
 
-const loadFile = file => FS.readFileSync(file, 'utf8');
-const reqFile = file => require(file); // eslint-disable-line global-require,import/no-dynamic-require
-
-module.exports = class Schema extends Node {
+/**
+ * Schema
+ *
+ * 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:
+ *
+ *    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 Schema extends TypeDefApi {
   constructor(schema) {
-    // Ensure schema
-    schema.resolvers = schema.resolvers || {};
-    schema.schemaDirectives = schema.schemaDirectives || {};
-    schema.context = schema.context || {};
-
-    //
-    super(schema.typeDefs);
-    this.schema = schema;
-    this.initialize();
+    super();
+    this.schema = { typeDefs: [], resolvers: {}, schemaDirectives: {} };
+    if (schema) this.mergeSchema(schema);
   }
 
-  initialize() {
-    const definitions = this.ast.definitions.map(d => new Node(d));
-    this.models = definitions.filter(d => d.isModel()).map(d => new Model(this, d.getAST()));
-    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 }), {});
-    this.inputs = definitions.filter(d => d.isInput()).map(d => new Model(this, d.getAST()));
-    this.scalars = definitions.filter(d => d.isScalar());
-    this.enums = definitions.filter(d => d.isEnum());
+  /**
+   * Synchronously merge a schema
+   */
+  mergeSchema(schema, options = {}) {
+    // Ensure this is a schema of sorts otherwise skip it
+    if (typeof schema !== 'string' && ['typeDefs', 'resolvers', 'schemaDirectives'].every(key => !schema[key])) return this;
+
+    // Here we want to normalize the schema into the shape { 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.resolvers) this.schema.resolvers = Merge(left.resolvers, right.resolvers);
+    if (normalizedSchema.schemaDirectives) this.schema.schemaDirectives = Merge(left.schemaDirectives, right.schemaDirectives);
+
+    // Chaining
+    return this;
   }
 
   /**
-   * This is the final call used to pass in a schema to makeExecutableSchema.
-   * Here I'm making last-minute modifications to the schema that is exposed to the API.
+   * Asynchronously load files from a given glob pattern and merge each schema
    */
-  getSchema() {
-    const definitions = this.ast.definitions.map((definition) => {
-      definition.fields = (definition.fields || []).filter((f) => {
-        const node = new Node(f, 'field');
-        const scope = nvl(uvl(node.getDirectiveArg('field', 'gqlScope'), 'crud'), '');
-        return scope.indexOf('r') > -1;
+  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));
       });
-
-      return definition;
     });
-
-    const ast = Object.assign({}, this.ast, { definitions });
-    const schema = Object.assign({}, this.schema, { typeDefs: ast });
-    validateSchema(schema);
-    return schema;
-  }
-
-  getModel(name) {
-    return this.modelsByName[name] || this.modelsByKey[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 }), {});
-  }
-
-  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;
-  }
-
-  getMarkedModels() {
-    return this.getModels().filter(model => model.isMarkedModel());
-  }
-
-  getEntityModels() {
-    return this.getModels().filter(model => model.isEntity());
+  /**
+   * 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() {
+    super.initialize(this.schema.typeDefs);
+    this.getModels().forEach(model => model.initialize());
+    return this;
   }
 
-  getContext() {
-    return this.schema.context;
+  /**
+   * 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;
   }
 
-  loadDir(dir, options) {
-    // Typedefs
-    const typeDefs = Glob.sync(`${dir}/**/*.{gql,graphql}`, options).map(file => loadFile(file)).join('\n\n');
-
-    // Possibly full schema definitions
-    const schema = Glob.sync(`${dir}/**/*.js`, options).map(file => reqFile(file)).reduce((prev, data) => {
-      return Merge(prev, data);
-    }, {
-      typeDefs: typeDefs.length ? typeDefs : undefined,
-      context: {},
-      resolvers: {},
-      schemaDirectives: {},
+  /**
+   * 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
+      },
     });
 
-    return this.extend(schema);
+    this.schema.typeDefs = { kind: Kind.DOCUMENT, definitions };
+    return this;
   }
 
-  sextend(...schemas) {
-    const definitions = schemas.filter(schema => schema.typeDefs).map(schema => mergeASTSchema(schema.typeDefs).definitions);
-    this.ast.definitions = mergeASTArray(this.ast.definitions.concat(...definitions));
-    this.schema.resolvers = Merge(schemas.reduce((prev, schema) => Merge(prev, schema.resolvers || {}), {}), this.schema.resolvers);
-    return this;
+  makeExecutableSchema() {
+    return makeExecutableSchema(this.schema);
   }
 
-  extend(...schemas) {
-    this.sextend(...schemas);
-    this.initialize();
-    return this;
+  toObject() {
+    return this.schema;
   }
 
-  makeExecutableSchema() {
-    return makeExecutableSchema(this.getSchema());
+  toString() {
+    return print(this.typeDefs);
   }
 };