@coderich/autograph 0.9.16 → 0.10.2

package/src/core/Rule.js

@@ -1,107 +0,0 @@
-const { get } = require('lodash');
-const isEmail = require('validator/lib/isEmail');
-const Boom = require('./Boom');
-const { map, ensureArray, hashObject } = require('../service/app.service');
-
-const instances = {};
-const jsStringMethods = ['endsWith', 'includes', 'match', 'search', 'startsWith'];
-
-class Rule {
-  constructor(thunk, options = {}, name = 'Unknown') {
-    const {
-      ignoreNull = true,
-      itemize = true,
-      toError = (field, value, msg) => Boom.notAcceptable(`Rule (${name}) failed for { ${field.getModel()}.${field}: ${value} }`),
-    } = (options || {});
-
-    return Object.defineProperty((field, val, query) => {
-      return new Promise((resolve, reject) => {
-        if (ignoreNull && val == null) return resolve();
-
-        if (ignoreNull && itemize) {
-          return Promise.all(ensureArray(map(val, async (v) => {
-            const err = await thunk(field, v, query);
-            if (err) return Promise.reject(toError(field, v));
-            return Promise.resolve();
-          }))).then(v => resolve()).catch(e => reject(e));
-        }
-
-        return Promise.all([(async () => {
-          const err = await thunk(field, val, query);
-          if (err) return Promise.reject(toError(field, val));
-          return Promise.resolve();
-        })()]).then(v => resolve()).catch(e => reject(e));
-      });
-    }, 'type', { value: 'rule' });
-  }
-
-  static factory(name, thunk, options = {}) {
-    return Object.defineProperty(Rule, name, {
-      value: (...args) => Object.defineProperty(new Rule(thunk(...args), options, name), 'method', { value: name }),
-      writable: options.writable,
-      enumerable: options.enumerable,
-    })[name];
-  }
-
-  static extend(name, instance) {
-    const invalidArg = () => { throw new Error('Invalid argument; expected Rule factory instance'); };
-    const { method = invalidArg(), type = invalidArg() } = instance;
-    if (type !== 'rule' || !Rule[method]) invalidArg();
-    return (instances[name] = instance);
-  }
-
-  static getInstances() {
-    const defaultRules = Object.entries(Rule).map(([name, method]) => ({ name, instance: method() }));
-    const customRules = Object.entries(instances).map(([name, instance]) => ({ name, instance }));
-    const rules = defaultRules.concat(customRules);
-    return rules.reduce((prev, { name, instance }) => Object.assign(prev, { [name]: instance }), {});
-  }
-}
-
-// Factory methods
-jsStringMethods.forEach(name => Rule.factory(name, (...args) => (f, v) => !String(v)[name](...args)));
-
-// Ensures Foreign Key relationships
-Rule.factory('ensureId', () => (f, v, q) => {
-  const { resolver } = q.toObject();
-  return resolver.match(f.getType()).id(v).one().then(doc => Boolean(doc == null));
-});
-
-// Enforces required fields (only during create)
-Rule.factory('required', () => (f, v, q) => {
-  const { crud, input } = q.toObject();
-  return (crud === 'create' ? v == null : Object.prototype.hasOwnProperty.call(input, f.getName()) && v == null);
-}, { ignoreNull: false, enumerable: true });
-
-// A field cannot hold a reference to itself (model)
-Rule.factory('selfless', () => (f, v, q) => {
-  const { doc } = q.toObject();
-  if (`${v}` === `${get(doc, 'id')}`) throw Boom.badRequest(`${f.getModel()}.${f.getName()} cannot hold a reference to itself`);
-  return false;
-}, { enumerable: true });
-
-// Once set it cannot be changed
-Rule.factory('immutable', () => (f, v, q) => {
-  const { doc, crud } = q.toObject();
-  const path = `${f.getModel()}.${f.getName()}`;
-  const p = path.substr(path.indexOf('.') + 1);
-  const oldVal = get(doc, p);
-  if (crud === 'update' && oldVal !== undefined && v !== undefined && `${hashObject(v)}` !== `${hashObject(oldVal)}`) throw Boom.badRequest(`${path} is immutable; cannot be changed once set`);
-  return false;
-}, { enumerable: true });
-
-Rule.factory('allow', (...args) => (f, v) => args.indexOf(v) === -1);
-Rule.factory('deny', (...args) => (f, v) => args.indexOf(v) > -1);
-Rule.factory('range', (min, max) => {
-  if (min == null) min = undefined;
-  if (max == null) max = undefined;
-  return (f, v) => {
-    const num = +v; // Coerce to number if possible
-    const test = Number.isNaN(num) ? v.length : num;
-    return test < min || test > max;
-  };
-}, { itemize: false });
-Rule.factory('email', () => (f, v) => !isEmail(v), { enumerable: true });
-Rule.factory('distinct', () => (f, v) => false, { enumerable: true });
-
-module.exports = Rule;

package/src/core/SchemaDecorator.js

@@ -1,46 +0,0 @@
-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/Transformer.js

@@ -1,68 +0,0 @@
-const { get, set, uniqWith } = require('lodash');
-const { map, serialize, castCmp, hashObject } = require('../service/app.service');
-
-const instances = {};
-let allInstances;
-
-const jsStringMethods = [
-  'charAt', 'charCodeAt', 'codePointAt', 'concat', 'indexOf', 'lastIndexOf', 'localeCompare',
-  'normalize', 'padEnd', 'padStart', 'repeat', 'replace', 'search', 'slice', 'split', 'substr', 'substring',
-  'toLocaleLowerCase', 'toLocaleUpperCase', 'toLowerCase', 'toString', 'toUpperCase', 'trim', 'trimEnd', 'trimStart', 'raw',
-];
-
-class Transformer {
-  constructor(thunk, options = {}) {
-    const { ignoreNull = true, itemize = true } = (options || {});
-
-    return Object.defineProperty((field, val, query) => {
-      if (ignoreNull && val == null) return val;
-      if (ignoreNull && itemize) return map(val, v => thunk(field, v, query));
-      return thunk(field, val, query);
-    }, 'type', { value: 'transformer' });
-  }
-
-  static factory(name, thunk, options = {}) {
-    return Object.defineProperty(Transformer, name, {
-      value: (...args) => Object.defineProperty(new Transformer(thunk(...args), options), 'method', { value: name }),
-      writable: options.writable,
-      enumerable: options.enumerable,
-    })[name];
-  }
-
-  static extend(name, instance) {
-    const invalidArg = () => { throw new Error('Invalid argument; expected Transformer factory instance'); };
-    const { method = invalidArg(), type = invalidArg() } = instance;
-    if (type !== 'transformer' || !Transformer[method]) invalidArg();
-    return (instances[name] = instance);
-  }
-
-  static getInstances() {
-    if (allInstances) return allInstances;
-    const defaultTransformers = Object.entries(Transformer).map(([name, method]) => ({ name, instance: method() }));
-    const customTransformers = Object.entries(instances).map(([name, instance]) => ({ name, instance }));
-    const transformers = defaultTransformers.concat(customTransformers);
-    allInstances = transformers.reduce((prev, { name, instance }) => Object.assign(prev, { [name]: instance }), {});
-    return allInstances;
-  }
-}
-
-// Factory methods
-const enumerables = ['toLowerCase', 'toUpperCase', 'trim', 'trimEnd', 'trimStart', 'toString'];
-jsStringMethods.forEach(name => Transformer.factory(name, (...args) => (f, v) => String(v)[name](...args), { enumerable: enumerables.indexOf(name) > -1 }));
-Transformer.factory('toTitleCase', () => (f, v) => v.replace(/\w\S*/g, w => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()), { enumerable: true });
-Transformer.factory('toLocaleTitleCase', (...args) => (f, v) => v.replace(/\w\S*/g, w => w.charAt(0).toLocaleUpperCase(...args) + w.slice(1).toLocaleLowerCase()));
-Transformer.factory('toSentenceCase', () => (f, v) => v.charAt(0).toUpperCase() + v.slice(1), { enumerable: true });
-Transformer.factory('toLocaleSentenceCase', (...args) => (f, v) => v.charAt(0).toLocaleUpperCase(...args) + v.slice(1));
-Transformer.factory('toId', () => (f, v) => f.getModel().idValue(v), { enumerable: true });
-Transformer.factory('toArray', () => (f, v) => (Array.isArray(v) ? v : [v]), { itemize: false, enumerable: true });
-Transformer.factory('toDate', () => (f, v) => new Date(v), { enumerable: true, writable: true });
-Transformer.factory('dedupe', () => (f, a) => uniqWith(a, (b, c) => hashObject(b) === hashObject(c)), { ignoreNull: false, enumerable: true });
-Transformer.factory('dedupeBy', key => (f, a) => uniqWith(a, (b, c) => hashObject(b[key]) === hashObject(c[key])), { ignoreNull: false, enumerable: true });
-Transformer.factory('timestamp', () => (f, v) => Date.now(), { enumerable: true });
-Transformer.factory('first', () => (f, v) => (Array.isArray(v) ? v[0] : v), { enumerable: true });
-Transformer.factory('get', path => (f, v) => get(v, path), { enumerable: true });
-Transformer.factory('set', path => (f, v) => set({}, path, v), { enumerable: true });
-Transformer.factory('cast', type => (f, v) => castCmp(type, v));
-Transformer.factory('serialize', () => (f, v) => serialize(f, v));
-
-module.exports = Transformer;

package/src/data/Memoizer.js

@@ -1,39 +0,0 @@
-/**
- * Memoizer.
- *
- * Keeps a memoized cache of function call results; executing them once and reusing the result.
- *
- * @param {Object} src - the object|function to memoize
- * @param {Array} whitelist - whitelist of src methods to memoize (defaults to enumerable functions)
- */
-module.exports = class Memoizer {
-  constructor(src, whitelist = Object.keys(src).filter(k => typeof src[k] === 'function')) {
-    const cache = {};
-
-    return new Proxy(src, {
-      // This gets called when accessing properties of an object
-      get(target, prop, rec) {
-        const value = Reflect.get(target, prop, rec);
-
-        if (typeof value === 'function') {
-          if (whitelist.indexOf(prop) === -1) return value.bind(target);
-
-          return (...args) => {
-            const key = `${prop}:${JSON.stringify(args)}`;
-            cache[key] = Object.prototype.hasOwnProperty.call(cache, key) ? cache[key] : value.bind(target)(...args);
-            return cache[key];
-          };
-        }
-
-        return value;
-      },
-
-      // This gets called when src is a function
-      apply(target, thisArg, args) {
-        const key = JSON.stringify(args);
-        cache[key] = Object.prototype.hasOwnProperty.call(cache, key) ? cache[key] : target.call(thisArg, ...args);
-        return cache[key];
-      },
-    });
-  }
-};

package/src/data/ResultSet.js

@@ -1,246 +0,0 @@
-const { get } = require('lodash');
-const DataService = require('./DataService');
-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();
-
-    ResultSet.ensureModelCache(model);
-
-    const { template, fieldDefs } = modelCache.get(model);
-
-    const rs = map(data, (doc) => {
-      if (doc == null || typeof doc !== 'object') return doc;
-
-      const instance = Object.create(template, {
-        $$services: {
-          value: {
-            cache: new Map(),
-            data: doc,
-            resolver,
-            query,
-            sort,
-          },
-          enumerable: false,
-        },
-      });
-
-      return new Proxy(instance, {
-        ownKeys(target) {
-          return Reflect.ownKeys(target).concat('id', fieldDefs.map(d => d.name));
-        },
-        getOwnPropertyDescriptor(target, prop) {
-          return (prop === 'id' || fieldDefs.find(el => el.name === prop)) ? { enumerable: true, configurable: true } : Reflect.getOwnPropertyDescriptor(target, prop);
-        },
-        getPrototypeOf() {
-          return { $$services: instance.$$services };
-        },
-        deleteProperty(target, prop) {
-          const { key = prop } = fieldDefs.find(d => d.name === prop);
-          delete instance[prop];
-          delete instance.$$services.data[key];
-        },
-      });
-    });
-
-    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,
-      },
-    });
-  }
-
-  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/graphql/ast/SchemaDecorator.js

@@ -1,138 +0,0 @@
-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);
-  }
-};