relay-compiler 1.3.0 → 1.5.0

package/lib/GraphQLCompilerContext.js

@@ -0,0 +1,158 @@
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ * @providesModule GraphQLCompilerContext
+ * @format
+ */
+
+'use strict';
+
+var _classCallCheck3 = _interopRequireDefault(require('babel-runtime/helpers/classCallCheck'));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
+
+var _require = require('./GraphQLCompilerUserError'),
+    createUserError = _require.createUserError;
+
+var _require2 = require('immutable'),
+    ImmutableOrderedMap = _require2.OrderedMap;
+
+/**
+ * An immutable representation of a corpus of documents being compiled together.
+ * For each document, the context stores the IR and any validation errors.
+ */
+var GraphQLCompilerContext = function () {
+  function GraphQLCompilerContext(serverSchema, clientSchema) {
+    (0, _classCallCheck3['default'])(this, GraphQLCompilerContext);
+
+    this._isMutable = false;
+    this._documents = new ImmutableOrderedMap();
+    this._withTransform = new WeakMap();
+    this.serverSchema = serverSchema;
+    // If a separate client schema doesn't exist, use the server schema.
+    this.clientSchema = clientSchema || serverSchema;
+  }
+
+  /**
+   * Returns the documents for the context in the order they were added.
+   */
+
+
+  GraphQLCompilerContext.prototype.documents = function documents() {
+    return this._documents.toArray();
+  };
+
+  GraphQLCompilerContext.prototype.forEachDocument = function forEachDocument(fn) {
+    this._documents.forEach(fn);
+  };
+
+  GraphQLCompilerContext.prototype.replace = function replace(node) {
+    return this._update(this._documents.update(node.name, function (existing) {
+      require('fbjs/lib/invariant')(existing, 'GraphQLCompilerContext: Expected to replace existing node %s, but' + 'one was not found in the context.', node.name);
+      return node;
+    }));
+  };
+
+  GraphQLCompilerContext.prototype.add = function add(node) {
+    return this._update(this._documents.update(node.name, function (existing) {
+      require('fbjs/lib/invariant')(!existing, 'GraphQLCompilerContext: Duplicate document named `%s`. GraphQL ' + 'fragments and roots must have unique names.', node.name);
+      return node;
+    }));
+  };
+
+  GraphQLCompilerContext.prototype.addAll = function addAll(nodes) {
+    return this.withMutations(function (mutable) {
+      return nodes.reduce(function (ctx, definition) {
+        return ctx.add(definition);
+      }, mutable);
+    });
+  };
+
+  /**
+   * Apply a list of compiler transforms and return a new compiler context.
+   */
+
+
+  GraphQLCompilerContext.prototype.applyTransforms = function applyTransforms(transforms, reporter) {
+    var _this = this;
+
+    return require('./GraphQLCompilerProfiler').run('applyTransforms', function () {
+      return transforms.reduce(function (ctx, transform) {
+        return ctx.applyTransform(transform, reporter);
+      }, _this);
+    });
+  };
+
+  /**
+   * Applies a transform to this context, returning a new context.
+   *
+   * This is memoized such that applying the same sequence of transforms will
+   * not result in duplicated work.
+   */
+
+
+  GraphQLCompilerContext.prototype.applyTransform = function applyTransform(transform, reporter) {
+    var transformed = this._withTransform.get(transform);
+    if (!transformed) {
+      var start = process.hrtime();
+      transformed = require('./GraphQLCompilerProfiler').instrument(transform)(this);
+      var delta = process.hrtime(start);
+      var deltaMs = Math.round((delta[0] * 1e9 + delta[1]) / 1e6);
+      reporter && reporter.reportTime(transform.name, deltaMs);
+      this._withTransform.set(transform, transformed);
+    }
+    return transformed;
+  };
+
+  GraphQLCompilerContext.prototype.get = function get(name) {
+    return this._documents.get(name);
+  };
+
+  GraphQLCompilerContext.prototype.getFragment = function getFragment(name) {
+    var node = this._get(name);
+    if (node.kind !== 'Fragment') {
+      var childModule = name.substring(0, name.lastIndexOf('_'));
+      throw createUserError('GraphQLCompilerContext: Cannot find fragment `%s`.' + ' Please make sure the fragment exists in `%s`.', name, childModule);
+    }
+    return node;
+  };
+
+  GraphQLCompilerContext.prototype.getRoot = function getRoot(name) {
+    var node = this._get(name);
+    require('fbjs/lib/invariant')(node.kind === 'Root', 'GraphQLCompilerContext: Expected `%s` to be a root, got `%s`.', name, node.kind);
+    return node;
+  };
+
+  GraphQLCompilerContext.prototype.remove = function remove(name) {
+    return this._update(this._documents['delete'](name));
+  };
+
+  GraphQLCompilerContext.prototype.withMutations = function withMutations(fn) {
+    var mutableCopy = this._update(this._documents.asMutable());
+    mutableCopy._isMutable = true;
+    var result = fn(mutableCopy);
+    result._isMutable = false;
+    result._documents = result._documents.asImmutable();
+    return this._documents === result._documents ? this : result;
+  };
+
+  GraphQLCompilerContext.prototype._get = function _get(name) {
+    var document = this._documents.get(name);
+    require('fbjs/lib/invariant')(document, 'GraphQLCompilerContext: Unknown document `%s`.', name);
+    return document;
+  };
+
+  GraphQLCompilerContext.prototype._update = function _update(documents) {
+    var context = this._isMutable ? this : new GraphQLCompilerContext(this.serverSchema, this.clientSchema);
+    context._documents = documents;
+    return context;
+  };
+
+  return GraphQLCompilerContext;
+}();
+
+module.exports = GraphQLCompilerContext;

package/lib/GraphQLCompilerProfiler.js

@@ -0,0 +1,271 @@
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ * @format
+ */
+
+'use strict';
+
+var _asyncToGenerator2 = require('babel-runtime/helpers/asyncToGenerator');
+
+var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * The compiler profiler builds a "call graph" of high level operations as a
+ * means of tracking time spent over the course of running the compiler.
+ */
+
+var enabled = false;
+var traces = [{
+  ph: 'M',
+  pid: 0,
+  tid: 0,
+  name: 'process_name',
+  args: { name: 'relay-compiler' }
+}, {
+  ph: 'M',
+  pid: 0,
+  tid: 0,
+  name: 'thread_name',
+  args: { name: 'relay-compiler' }
+}];
+var stack = [];
+
+function enable() {
+  enabled = true;
+}
+
+function getTraces() {
+  return traces;
+}
+
+/**
+ * Run the provided function as part of a stack profile.
+ */
+function run(name, fn) {
+  return instrument(fn, name)();
+}
+
+/**
+ * Run the provided async function as part context in a stack profile.
+ * See instrumentAsyncContext() for limitations and usage notes.
+ */
+function asyncContext(name, fn) {
+  return instrumentAsyncContext(fn, name)();
+}
+
+/**
+ * Wait for the provided async operation as an async profile.
+ */
+function waitFor(name, fn) {
+  return instrumentWait(fn, name)();
+}
+
+/**
+ * Return a new instrumented sync function to be part of a stack profile.
+ *
+ * This instruments synchronous functions to be displayed in a stack
+ * visualization. To instrument async functions, see instrumentAsyncContext()
+ * and instrumentWait().
+ */
+function instrument(fn, name) {
+  if (!enabled) {
+    return fn;
+  }
+  var profileName = name || fn.displayName || fn.name;
+  var instrumented = function instrumented() {
+    var traceId = start(profileName);
+    try {
+      return fn.apply(this, arguments);
+    } finally {
+      end(traceId);
+    }
+  };
+  instrumented.displayName = profileName;
+  return instrumented;
+}
+
+/**
+ * Return a new instrumented async function which provides context for a stack.
+ *
+ * Because the resulting profiling information will be incorporated into a
+ * stack visualization, the instrumented function must represent a distinct
+ * region of time which does not overlap with any other async context.
+ *
+ * In other words, functions instrumented with instrumentAsyncContext must not
+ * run in parallel via Promise.all().
+ *
+ * To instrument functions which will run in parallel, use instrumentWait().
+ */
+function instrumentAsyncContext(fn, name) {
+  if (!enabled) {
+    return fn;
+  }
+  var profileName = name || fn.displayName || fn.name;
+  var instrumented = (() => {
+    var _ref = (0, _asyncToGenerator3.default)(function* () {
+      var traceId = start(profileName);
+      try {
+        return yield fn.apply(this, arguments);
+      } finally {
+        end(traceId);
+      }
+    });
+
+    function instrumented() {
+      return _ref.apply(this, arguments);
+    }
+
+    return instrumented;
+  })();
+  instrumented.displayName = profileName;
+  return instrumented;
+}
+
+/**
+ * Return a new instrumented function which performs an awaited async operation.
+ *
+ * The instrumented function is not included in the overall run time of the
+ * compiler, instead it captures the time waiting on some asynchronous external
+ * resource such as network or filesystem which are often run in parallel.
+ */
+function instrumentWait(fn, name) {
+  if (!enabled) {
+    return fn;
+  }
+  var profileName = name || fn.displayName || fn.name;
+  var instrumented = (() => {
+    var _ref2 = (0, _asyncToGenerator3.default)(function* () {
+      var traceId = startWait(profileName);
+      try {
+        return yield fn.apply(this, arguments);
+      } finally {
+        end(traceId);
+      }
+    });
+
+    function instrumented() {
+      return _ref2.apply(this, arguments);
+    }
+
+    return instrumented;
+  })();
+  instrumented.displayName = profileName;
+  return instrumented;
+}
+
+var T_ZERO = process.hrtime();
+
+// Return a Uint32 of microtime duration since program start.
+function microtime() {
+  var hrtime = process.hrtime(T_ZERO);
+  // eslint-disable-next-line no-bitwise
+  return 0 | hrtime[0] * 1e6 + Math.round(hrtime[1] / 1e3);
+}
+
+/**
+ * Start a stack profile with a particular name, returns an ID to pass to end().
+ *
+ * Other profiles may start before this one ends, which will be represented as
+ * nested operations, however all nested operations must end before this ends.
+ *
+ * In particular, be careful to end after errors.
+ */
+function start(name) {
+  var beginTrace = {
+    ph: 'B',
+    name: name,
+    pid: 0,
+    tid: 0,
+    ts: microtime()
+  };
+  traces.push(beginTrace);
+  stack.push(beginTrace);
+  return traces.length - 1;
+}
+
+var asyncID = 0;
+
+/**
+ * Start an async wait profile with a particular name, returns an ID to pass
+ * to end().
+ *
+ * Other profiles may start before this one ends, which will be represented as
+ * nested operations, however all nested operations must end before this ends.
+ *
+ * In particular, be careful to end after errors.
+ */
+function startWait(name) {
+  traces.push({
+    ph: 'b',
+    name: name,
+    cat: 'wait',
+    id: asyncID++,
+    pid: 0,
+    tid: 0,
+    ts: microtime()
+  });
+  return traces.length - 1;
+}
+
+function end(traceIdx) {
+  var trace = traces[traceIdx];
+
+  if (trace.ph === 'b') {
+    traces.push({
+      ph: 'e',
+      cat: trace.cat,
+      name: trace.name,
+      id: trace.id,
+      pid: trace.pid,
+      tid: trace.tid,
+      ts: microtime()
+    });
+    return;
+  }
+
+  require('fbjs/lib/invariant')(trace.ph === 'B', 'Begin trace phase');
+  require('fbjs/lib/invariant')(stack.pop() === trace, 'GraphQLCompilerProfiler: The profile trace %s ended before nested traces. ' + 'If it is async, try using Profile.waitFor or Profile.profileWait.', trace.name);
+
+  var prevTrace = traces[traces.length - 1];
+
+  if (trace === prevTrace) {
+    traces[traceIdx] = {
+      ph: 'X',
+      name: trace.name,
+      pid: trace.pid,
+      tid: trace.tid,
+      ts: trace.ts,
+      dur: microtime() - trace.ts
+    };
+    return;
+  }
+
+  traces.push({
+    ph: 'E',
+    name: trace.name,
+    pid: trace.pid,
+    tid: trace.tid,
+    ts: microtime()
+  });
+}
+
+module.exports = {
+  enable: enable,
+  getTraces: getTraces,
+  run: run,
+  asyncContext: asyncContext,
+  waitFor: waitFor,
+  instrument: instrument,
+  instrumentAsyncContext: instrumentAsyncContext,
+  instrumentWait: instrumentWait,
+  start: start,
+  startWait: startWait,
+  end: end
+};

package/lib/GraphQLCompilerPublic.js

@@ -1,10 +1,8 @@
 /**
  * Copyright (c) 2013-present, Facebook, Inc.
- * All rights reserved.
  *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
  *
  * 
  * @providesModule GraphQLCompilerPublic
@@ -13,30 +11,37 @@
 
 'use strict';
 
+var _require = require('./SourceControl'),
+    SourceControlMercurial = _require.SourceControlMercurial;
+
 module.exports = {
   ASTConvert: require('./ASTConvert'),
   CodegenDirectory: require('./CodegenDirectory'),
-  CodegenRunner: require('./RelayCodegenRunner'),
-  Compiler: require('./RelayCompiler'),
-  CompilerContext: require('./RelayCompilerContext'),
-  ConsoleReporter: require('./RelayConsoleReporter'),
-  FileParser: require('./FileParser'),
+  CodegenRunner: require('./CodegenRunner'),
+  CodegenWatcher: require('./CodegenWatcher'),
+  CompilerContext: require('./GraphQLCompilerContext'),
+  ConsoleReporter: require('./GraphQLConsoleReporter'),
+  DotGraphQLParser: require('./DotGraphQLParser'),
+  ASTCache: require('./ASTCache'),
+  IRTransformer: require('./GraphQLIRTransformer'),
+  IRVisitor: require('./GraphQLIRVisitor'),
+  MultiReporter: require('./GraphQLMultiReporter'),
+  Parser: require('./GraphQLParser'),
+  Printer: require('./GraphQLIRPrinter'),
+  Profiler: require('./GraphQLCompilerProfiler'),
+  SchemaUtils: require('./GraphQLSchemaUtils'),
+  SourceControlMercurial: SourceControlMercurial,
+  Validator: require('./GraphQLValidator'),
+  WatchmanClient: require('./GraphQLWatchmanClient'),
   filterContextForNode: require('./filterContextForNode'),
-  GraphQLFileParser: require('./GraphQLFileParser'),
-  GraphQLIRTransforms: require('./GraphQLIRTransforms'),
-  getIdentifierForRelayArgumentValue: require('./getIdentifierForRelayArgumentValue'),
-  GraphQLSchemaUtils: require('./GraphQLSchemaUtils'),
-  GraphQLTextParser: require('./GraphQLTextParser'),
-  GraphQLValidator: require('./GraphQLValidator'),
-  IRTransformer: require('./RelayIRTransformer'),
-  IRVisitor: require('./RelayIRVisitor'),
-  MultiReporter: require('./RelayMultiReporter'),
-  RelayParser: require('./RelayParser'),
-  Printer: require('./RelayPrinter'),
+  getIdentifierForArgumentValue: require('./getIdentifierForArgumentValue'),
+  getLiteralArgumentValues: require('./getLiteralArgumentValues'),
+  isEquivalentType: require('./isEquivalentType'),
+  nullthrows: require('./nullthrowsOSS'),
 
-  AutoAliasTransform: require('./AutoAliasTransform'),
   FilterDirectivesTransform: require('./FilterDirectivesTransform'),
-  FlattenTransform: require('./RelayFlattenTransform'),
+  FlattenTransform: require('./FlattenTransform'),
+  InlineFragmentsTransform: require('./InlineFragmentsTransform'),
   SkipClientFieldTransform: require('./SkipClientFieldTransform'),
   SkipRedundantNodesTransform: require('./SkipRedundantNodesTransform'),
   SkipUnreachableNodeTransform: require('./SkipUnreachableNodeTransform'),

package/lib/GraphQLCompilerUserError.js

@@ -0,0 +1,26 @@
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule GraphQLCompilerUserError
+ * 
+ * @format
+ */
+
+'use strict';
+
+var createUserError = function createUserError(format) {
+  for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    args[_key - 1] = arguments[_key];
+  }
+
+  var index = 0;
+  var formatted = format.replace(/%s/g, function (match) {
+    return args[index++];
+  });
+  return new Error(formatted);
+};
+
+module.exports = { createUserError: createUserError };

package/lib/GraphQLConsoleReporter.js

@@ -0,0 +1,58 @@
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule GraphQLConsoleReporter
+ * 
+ * @format
+ */
+
+'use strict';
+
+var _classCallCheck3 = _interopRequireDefault(require('babel-runtime/helpers/classCallCheck'));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
+
+var GraphQLConsoleReporter = function () {
+  function GraphQLConsoleReporter(options) {
+    (0, _classCallCheck3['default'])(this, GraphQLConsoleReporter);
+
+    this._verbose = options.verbose;
+    this._quiet = options.quiet;
+  }
+
+  GraphQLConsoleReporter.prototype.reportMessage = function reportMessage(message) {
+    if (!this._quiet) {
+      process.stdout.write(message + '\n');
+    }
+  };
+
+  GraphQLConsoleReporter.prototype.reportTime = function reportTime(name, ms) {
+    if (this._verbose && !this.quiet) {
+      var time = ms === 0 ? require('chalk').gray(' <1ms') : ms < 1000 ? require('chalk').blue(leftPad(5, ms + 'ms')) : require('chalk').red(Math.floor(ms / 10) / 100 + 's');
+      process.stdout.write('  ' + time + ' ' + require('chalk').gray(name) + '\n');
+    }
+  };
+
+  GraphQLConsoleReporter.prototype.reportError = function reportError(caughtLocation, error) {
+    if (!this._quiet) {
+      process.stdout.write(require('chalk').red('ERROR:\n' + error.message + '\n'));
+      if (this._verbose) {
+        var frames = error.stack.match(/^ {4}at .*$/gm);
+        if (frames) {
+          process.stdout.write(require('chalk').gray('From: ' + caughtLocation + '\n' + frames.join('\n') + '\n'));
+        }
+      }
+    }
+  };
+
+  return GraphQLConsoleReporter;
+}();
+
+function leftPad(len, str) {
+  return new Array(len - str.length + 1).join(' ') + str;
+}
+
+module.exports = GraphQLConsoleReporter;

package/lib/GraphQLIR.js

@@ -0,0 +1,12 @@
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule GraphQLIR
+ * 
+ * @format
+ */
+
+'use strict';