@ardatan/relay-compiler 12.0.0

package/lib/core/CompilerError.js

@@ -0,0 +1,251 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ * @format
+ */
+// flowlint ambiguous-object-type:error
+'use strict';
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _createForOfIteratorHelper2 = _interopRequireDefault(require("@babel/runtime/helpers/createForOfIteratorHelper"));
+
+var _require = require('graphql'),
+    GraphQLError = _require.GraphQLError;
+
+/**
+ * Creates an error describing invalid application code (GraphQL/Schema)
+ * that must be fixed by the end developer. This should only be used
+ * for local errors that don't affect processing of other user code.
+ */
+function createUserError(message, locations, nodes) {
+  var messageWithLocations = message;
+
+  if (locations != null) {
+    var printedLocations = printLocations(locations);
+    messageWithLocations = printedLocations.length === 0 ? message : [message].concat(printedLocations).join('\n\n') + '\n';
+  }
+
+  return new GraphQLError(messageWithLocations, nodes !== null && nodes !== void 0 ? nodes : []);
+}
+/**
+ * Similar to createUserError but for errors that are *not* recoverable:
+ * the compiler should not continue to process other inputs because their
+ * validity can't be determined.
+ */
+
+
+function createNonRecoverableUserError(message, locations, nodes) {
+  var messageWithLocations = message;
+
+  if (locations != null) {
+    var printedLocations = printLocations(locations);
+    messageWithLocations = printedLocations.length === 0 ? message : [message].concat(printedLocations).join('\n\n') + '\n';
+  }
+
+  var error = new GraphQLError(messageWithLocations, nodes !== null && nodes !== void 0 ? nodes : []);
+  return new Error(error.message);
+}
+/**
+ * Creates an error describing a problem with the compiler itself - such
+ * as a broken invariant - that must be fixed within the compiler.
+ */
+
+
+function createCompilerError(message, locations, nodes) {
+  var messageWithLocations = message;
+
+  if (locations != null) {
+    var printedLocations = printLocations(locations);
+    messageWithLocations = printedLocations.length === 0 ? message : [message].concat(printedLocations).join('\n\n') + '\n';
+  }
+
+  var error = new GraphQLError("Internal Error: ".concat(messageWithLocations), nodes !== null && nodes !== void 0 ? nodes : []);
+  return new Error(error.message);
+}
+/**
+ * Iterates over the elements of some iterable value, calling the
+ * supplied callback for each item with a guard for user errors.
+ *
+ * Non-user errors abort the iteration and are instantly rethrown.
+ * User errors are collected and rethrown at the end, if multiple user errors
+ * occur, a combined error is thrown.
+ */
+
+
+function eachWithCombinedError(iterable, fn) {
+  var errors = [];
+
+  var _iterator = (0, _createForOfIteratorHelper2["default"])(iterable),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var item = _step.value;
+
+      try {
+        fn(item);
+      } catch (error) {
+        if (error instanceof GraphQLError) {
+          errors.push(error);
+        } else {
+          throw error;
+        }
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+
+  if (errors.length > 0) {
+    if (errors.length === 1) {
+      throw createUserError(String(errors[0]).split('\n').map(function (line, index) {
+        return index === 0 ? "- ".concat(line) : "  ".concat(line);
+      }).join('\n'));
+    }
+
+    throw createUserError("Encountered ".concat(errors.length, " errors:\n") + errors.map(function (error) {
+      return String(error).split('\n').map(function (line, index) {
+        return index === 0 ? "- ".concat(line) : "  ".concat(line);
+      }).join('\n');
+    }).join('\n'));
+  }
+}
+
+function printLocations(locations) {
+  var printedLocations = [];
+
+  var _iterator2 = (0, _createForOfIteratorHelper2["default"])(locations),
+      _step2;
+
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var location = _step2.value;
+      var sourceLocation = location;
+
+      while (sourceLocation.kind === 'Derived') {
+        sourceLocation = sourceLocation.source;
+      }
+
+      switch (sourceLocation.kind) {
+        case 'Source':
+          {
+            // source location
+            var prefix = sourceLocation === location ? 'Source: ' : 'Source (derived): ';
+            printedLocations.push(prefix + highlightSourceAtLocation(sourceLocation.source, getLocation(sourceLocation.source, sourceLocation.start)));
+            break;
+          }
+
+        case 'Generated':
+          {
+            printedLocations.push('Source: (generated)');
+            break;
+          }
+
+        case 'Unknown':
+          {
+            printedLocations.push('Source: (unknown)');
+            break;
+          }
+
+        default:
+          {
+            sourceLocation;
+            throw createCompilerError("CompilerError: cannot print location '".concat(String(sourceLocation), "'."));
+          }
+      }
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+
+  return printedLocations;
+}
+/**
+ * Render a helpful description of the location of the error in the GraphQL
+ * Source document.
+ */
+
+
+function highlightSourceAtLocation(source, location) {
+  var firstLineColumnOffset = source.locationOffset.column - 1;
+  var body = whitespace(firstLineColumnOffset) + source.body;
+  var lineIndex = location.line - 1;
+  var lineOffset = source.locationOffset.line - 1;
+  var lineNum = location.line + lineOffset;
+  var columnOffset = location.line === 1 ? firstLineColumnOffset : 0;
+  var columnNum = location.column + columnOffset;
+  var lines = body.split(/\r\n|[\n\r]/g);
+  return "".concat(source.name, " (").concat(lineNum, ":").concat(columnNum, ")\n") + printPrefixedLines([// Lines specified like this: ["prefix", "string"],
+  ["".concat(lineNum - 1, ": "), lines[lineIndex - 1]], ["".concat(lineNum, ": "), lines[lineIndex]], ['', whitespace(columnNum - 1) + '^'], ["".concat(lineNum + 1, ": "), lines[lineIndex + 1]]]);
+}
+
+function printPrefixedLines(lines) {
+  var existingLines = lines.filter(function (_ref) {
+    var _ = _ref[0],
+        line = _ref[1];
+    return line !== undefined;
+  });
+  var padLen = 0;
+
+  var _iterator3 = (0, _createForOfIteratorHelper2["default"])(existingLines),
+      _step3;
+
+  try {
+    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+      var _step3$value = _step3.value,
+          prefix = _step3$value[0];
+      padLen = Math.max(padLen, prefix.length);
+    }
+  } catch (err) {
+    _iterator3.e(err);
+  } finally {
+    _iterator3.f();
+  }
+
+  return existingLines.map(function (_ref2) {
+    var prefix = _ref2[0],
+        line = _ref2[1];
+    return lpad(padLen, prefix) + line;
+  }).join('\n');
+}
+
+function whitespace(len) {
+  return Array(len + 1).join(' ');
+}
+
+function lpad(len, str) {
+  return whitespace(len - str.length) + str;
+}
+
+function getLocation(source, position) {
+  var lineRegexp = /\r\n|[\n\r]/g;
+  var line = 1;
+  var column = position + 1;
+  var match;
+
+  while ((match = lineRegexp.exec(source.body)) && match.index < position) {
+    line += 1;
+    column = position + 1 - (match.index + match[0].length);
+  }
+
+  return {
+    line: line,
+    column: column
+  };
+}
+
+module.exports = {
+  createCompilerError: createCompilerError,
+  createNonRecoverableUserError: createNonRecoverableUserError,
+  createUserError: createUserError,
+  eachWithCombinedError: eachWithCombinedError
+};

package/lib/core/DotGraphQLParser.js

@@ -0,0 +1,40 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ * @format
+ */
+// flowlint ambiguous-object-type:error
+'use strict';
+
+var ASTCache = require('./ASTCache');
+
+var fs = require('fs');
+
+var path = require('path');
+
+var _require = require('graphql'),
+    parse = _require.parse,
+    Source = _require.Source;
+
+function parseFile(baseDir, file) {
+  var text = fs.readFileSync(path.join(baseDir, file.relPath), 'utf8');
+  return parse(new Source(text, file.relPath), {
+    experimentalFragmentVariables: true
+  });
+}
+
+function getParser(baseDir) {
+  return new ASTCache({
+    baseDir: baseDir,
+    parse: parseFile
+  });
+}
+
+module.exports = {
+  parseFile: parseFile,
+  getParser: getParser
+};

package/lib/core/GraphQLCompilerProfiler.js

@@ -0,0 +1,299 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ * @format
+ */
+// flowlint ambiguous-object-type:error
+'use strict';
+
+var _asyncToGenerator = require("@babel/runtime/helpers/asyncToGenerator");
+
+var invariant = require('invariant');
+/**
+ * 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) {
+  var _ref;
+
+  if (!enabled) {
+    return fn;
+  }
+
+  var profileName = (_ref = name !== null && name !== void 0 ? name : // $FlowFixMe[prop-missing] - Flow no longer considers statics of functions as any
+  fn.displayName) !== null && _ref !== void 0 ? _ref : 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) {
+  var _ref2;
+
+  if (!enabled) {
+    return fn;
+  }
+
+  var profileName = (_ref2 = name !== null && name !== void 0 ? name : // $FlowFixMe[prop-missing] - Flow no longer considers statics of functions as any
+  fn.displayName) !== null && _ref2 !== void 0 ? _ref2 : fn.name;
+
+  var instrumented = /*#__PURE__*/function () {
+    var _instrumented = _asyncToGenerator(function* () {
+      var traceId = start(profileName);
+
+      try {
+        return yield fn.apply(this, arguments);
+      } finally {
+        end(traceId);
+      }
+    });
+
+    function instrumented() {
+      return _instrumented.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) {
+  var _ref3;
+
+  if (!enabled) {
+    return fn;
+  }
+
+  var profileName = (_ref3 = name !== null && name !== void 0 ? name : // $FlowFixMe[prop-missing] - Flow no longer considers statics of functions as any
+  fn.displayName) !== null && _ref3 !== void 0 ? _ref3 : fn.name;
+
+  var instrumented = /*#__PURE__*/function () {
+    var _instrumented2 = _asyncToGenerator(function* () {
+      var traceId = startWait(profileName);
+
+      try {
+        return yield fn.apply(this, arguments);
+      } finally {
+        end(traceId);
+      }
+    });
+
+    function instrumented() {
+      return _instrumented2.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;
+  }
+
+  !(trace.ph === 'B') ? process.env.NODE_ENV !== "production" ? invariant(false, 'Begin trace phase') : invariant(false) : void 0;
+  !(stack.pop() === trace) ? process.env.NODE_ENV !== "production" ? invariant(false, 'GraphQLCompilerProfiler: The profile trace %s ended before nested traces. ' + 'If it is async, try using Profile.waitFor or Profile.profileWait.', trace.name) : invariant(false) : void 0;
+  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/core/GraphQLDerivedFromMetadata.js

@@ -0,0 +1,31 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ * @format
+ */
+// flowlint ambiguous-object-type:error
+'use strict';
+
+/**
+ * Helpers to retieve the name of the document from which the input derives:
+ * this is either the name of the input itself (if it is not a derived node)
+ * or the metadata.derivedFrom property for derived nodes.
+ */
+// Version for generated nodes
+function getReaderSourceDefinitionName(node) {
+  var _node$params$metadata, _node$metadata;
+
+  var _ref = node.kind === 'Request' ? [node.params.name, (_node$params$metadata = node.params.metadata) === null || _node$params$metadata === void 0 ? void 0 : _node$params$metadata.derivedFrom] : node.kind === 'SplitOperation' ? [node.name, (_node$metadata = node.metadata) === null || _node$metadata === void 0 ? void 0 : _node$metadata.derivedFrom] : [node.name, null],
+      name = _ref[0],
+      derivedFrom = _ref[1];
+
+  return typeof derivedFrom === 'string' ? derivedFrom : name;
+}
+
+module.exports = {
+  getReaderSourceDefinitionName: getReaderSourceDefinitionName
+};