@ardatan/relay-compiler 12.0.0

package/lib/codegen/writeRelayGeneratedFile.js

@@ -0,0 +1,208 @@
+/**
+ * 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 _asyncToGenerator = require("@babel/runtime/helpers/asyncToGenerator");
+
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+
+var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
+
+var CodeMarker = require('../util/CodeMarker');
+
+var createPrintRequireModuleDependency = require('./createPrintRequireModuleDependency');
+
+var dedupeJSONStringify = require('../util/dedupeJSONStringify');
+
+var invariant = require('invariant');
+
+var md5 = require('../util/md5');
+
+var _require = require('relay-runtime'),
+    RelayConcreteNode = _require.RelayConcreteNode;
+
+function getConcreteType(node) {
+  switch (node.kind) {
+    case RelayConcreteNode.FRAGMENT:
+      return 'ReaderFragment';
+
+    case RelayConcreteNode.REQUEST:
+      return 'ConcreteRequest';
+
+    case RelayConcreteNode.SPLIT_OPERATION:
+      return 'NormalizationSplitOperation';
+
+    case RelayConcreteNode.INLINE_DATA_FRAGMENT:
+      return 'ReaderInlineDataFragment';
+
+    default:
+      node;
+      !false ? process.env.NODE_ENV !== "production" ? invariant(false, 'Unexpected GeneratedNode kind: `%s`.', node.kind) : invariant(false) : void 0;
+  }
+}
+
+function writeRelayGeneratedFile(schema, codegenDir, definition, _generatedNode, formatModule, typeText, _persistQuery, sourceHash, extension) {
+  var printModuleDependency = arguments.length > 9 && arguments[9] !== undefined ? arguments[9] : createPrintRequireModuleDependency();
+  var shouldRepersist = arguments.length > 10 ? arguments[10] : undefined;
+  var writeQueryParameters = arguments.length > 11 ? arguments[11] : undefined;
+  var languagePlugin = arguments.length > 12 ? arguments[12] : undefined;
+  var generatedNode = _generatedNode; // Copy to const so Flow can refine.
+
+  var persistQuery = _persistQuery;
+  var operationName = generatedNode.kind === 'Request' ? generatedNode.params.name : generatedNode.name;
+  var moduleName = (languagePlugin === null || languagePlugin === void 0 ? void 0 : languagePlugin.getModuleName) ? languagePlugin.getModuleName(operationName) : operationName + '.graphql';
+  var filename = moduleName + '.' + extension;
+  var queryParametersFilename = generatedNode.kind === 'Request' ? "".concat(generatedNode.params.name, "$Parameters.").concat(extension) : null;
+  var typeName = getConcreteType(generatedNode);
+  var docText;
+
+  if (generatedNode.kind === RelayConcreteNode.REQUEST) {
+    docText = generatedNode.params.text != null ? generatedNode.params.text : null;
+  } // Use `Promise.resolve` to work around a Babel 7.8/7.9 issue.
+
+
+  return Promise.resolve().then( /*#__PURE__*/_asyncToGenerator(function* () {
+    var _generatedNode$metada;
+
+    var hash = null;
+
+    if (generatedNode.kind === RelayConcreteNode.REQUEST) {
+      !(docText != null) ? process.env.NODE_ENV !== "production" ? invariant(false, 'writeRelayGeneratedFile: Expected `text` for operations to be set.') : invariant(false) : void 0;
+      var _generatedNode$params = generatedNode.params.metadata,
+          _ignored = _generatedNode$params.isRefetchableQuery,
+          _ignored2 = _generatedNode$params.derivedFrom,
+          nextMetadata = (0, _objectWithoutPropertiesLoose2["default"])(_generatedNode$params, ["isRefetchableQuery", "derivedFrom"]);
+      var nextRequestParams;
+
+      if (persistQuery != null) {
+        hash = md5(docText);
+        var id = null;
+
+        if (!shouldRepersist) {
+          // Unless we `shouldRepersist` the query, check if the @relayHash matches
+          // the operation text of the current text and re-use the persisted
+          // operation id.
+          var oldContent = codegenDir.read(filename);
+          var oldHash = extractHash(oldContent);
+          var oldRequestID = extractRelayRequestID(oldContent);
+
+          if (hash === oldHash && oldRequestID != null) {
+            id = oldRequestID;
+          }
+        }
+
+        if (id == null) {
+          // $FlowFixMe[incompatible-call]
+          id = yield persistQuery(docText);
+        }
+
+        nextRequestParams = {
+          id: id,
+          metadata: nextMetadata,
+          // $FlowFixMe[prop-missing]
+          // $FlowFixMe[incompatible-use]
+          name: generatedNode.params.name,
+          // $FlowFixMe[prop-missing]
+          // $FlowFixMe[incompatible-use]
+          operationKind: generatedNode.params.operationKind,
+          text: null
+        };
+      } else {
+        nextRequestParams = {
+          cacheID: md5(docText),
+          id: null,
+          metadata: nextMetadata,
+          // $FlowFixMe[prop-missing]
+          // $FlowFixMe[incompatible-use]
+          name: generatedNode.params.name,
+          // $FlowFixMe[prop-missing]
+          // $FlowFixMe[incompatible-use]
+          operationKind: generatedNode.params.operationKind,
+          text: docText
+        };
+      } // $FlowFixMe[incompatible-type]
+
+
+      generatedNode = (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, generatedNode), {}, {
+        // $FlowFixMe[incompatible-type]
+        params: nextRequestParams
+      });
+    } // Strip metadata only used within the compiler
+
+
+    if (generatedNode.kind === RelayConcreteNode.SPLIT_OPERATION && ((_generatedNode$metada = generatedNode.metadata) === null || _generatedNode$metada === void 0 ? void 0 : _generatedNode$metada.derivedFrom) != null) {
+      var _generatedNode$metada2 = generatedNode.metadata,
+          _ignored3 = _generatedNode$metada2.derivedFrom,
+          metadata = (0, _objectWithoutPropertiesLoose2["default"])(_generatedNode$metada2, ["derivedFrom"]); // $FlowFixMe[incompatible-type]
+
+      generatedNode = (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, generatedNode), {}, {
+        metadata: metadata
+      });
+    }
+
+    var moduleText = formatModule({
+      moduleName: moduleName,
+      documentType: typeName,
+      definition: definition,
+      kind: generatedNode.kind,
+      docText: docText,
+      typeText: typeText,
+      hash: hash != null ? "@relayHash ".concat(hash) : null,
+      concreteText: CodeMarker.postProcess(dedupeJSONStringify(generatedNode), printModuleDependency),
+      sourceHash: sourceHash,
+      // $FlowFixMe[incompatible-call]
+      node: generatedNode,
+      schema: schema
+    });
+    codegenDir.writeFile(filename, moduleText, shouldRepersist);
+
+    if (writeQueryParameters && queryParametersFilename != null && generatedNode.kind === RelayConcreteNode.REQUEST && // $FlowFixMe[incompatible-type]
+    generatedNode.params.operationKind === 'query') {
+      writeQueryParameters(codegenDir, queryParametersFilename, moduleName, // $FlowFixMe[incompatible-call]
+      generatedNode.params);
+    } // $FlowFixMe[incompatible-call]
+
+
+    return generatedNode;
+  }));
+}
+
+function extractHash(text) {
+  if (text == null || text.length === 0) {
+    return null;
+  }
+
+  if (/<<<<<|>>>>>/.test(text)) {
+    // looks like a merge conflict
+    return null;
+  }
+
+  var match = text.match(/@relayHash (\w{32})\b/m);
+  return match && match[1];
+}
+
+function extractRelayRequestID(text) {
+  if (text == null || text.length === 0) {
+    return null;
+  }
+
+  if (/<<<<<|>>>>>/.test(text)) {
+    // looks like a merge conflict
+    return null;
+  }
+
+  var match = text.match(/@relayRequestID (.+)/);
+  return match ? match[1] : null;
+}
+
+module.exports = writeRelayGeneratedFile;

package/lib/core/ASTCache.js

@@ -0,0 +1,70 @@
+/**
+ * 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 Profiler = require('./GraphQLCompilerProfiler'); // $FlowFixMe[untyped-import] : Immutable is not typed
+
+
+var _require = require('immutable'),
+    ImmutableMap = _require.Map;
+
+var ASTCache = /*#__PURE__*/function () {
+  function ASTCache(config) {
+    this._documents = new Map();
+    this._baseDir = config.baseDir;
+    this._parse = Profiler.instrument(config.parse, 'ASTCache.parseFn');
+  } // Short-term: we don't do subscriptions/delta updates, instead always use all definitions
+  // $FlowFixMe[value-as-type]
+
+
+  var _proto = ASTCache.prototype;
+
+  _proto.documents = function documents() {
+    return ImmutableMap(this._documents);
+  } // parse should return the set of changes
+  ;
+
+  _proto.parseFiles = function parseFiles(files) {
+    var _this = this;
+
+    var documents = ImmutableMap();
+    files.forEach(function (file) {
+      if (!file.exists) {
+        _this._documents["delete"](file.relPath);
+
+        return;
+      }
+
+      var doc = function () {
+        try {
+          return _this._parse(_this._baseDir, file);
+        } catch (error) {
+          throw new Error("Parse error: ".concat(error, " in \"").concat(file.relPath, "\""));
+        }
+      }();
+
+      if (!doc) {
+        _this._documents["delete"](file.relPath);
+
+        return;
+      }
+
+      documents = documents.set(file.relPath, doc);
+
+      _this._documents.set(file.relPath, doc);
+    });
+    return documents;
+  };
+
+  return ASTCache;
+}();
+
+module.exports = ASTCache;

package/lib/core/ASTConvert.js

@@ -0,0 +1,198 @@
+/**
+ * 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 Profiler = require('./GraphQLCompilerProfiler');
+
+var _require = require('./SchemaUtils'),
+    isExecutableDefinitionAST = _require.isExecutableDefinitionAST,
+    isSchemaDefinitionAST = _require.isSchemaDefinitionAST;
+
+var _require2 = require('graphql'),
+    extendSchema = _require2.extendSchema,
+    parse = _require2.parse,
+    print = _require2.print,
+    visit = _require2.visit;
+
+function convertASTDocuments(schema, documents, transform) {
+  return Profiler.run('ASTConvert.convertASTDocuments', function () {
+    var definitions = definitionsFromDocuments(documents);
+    var astDefinitions = [];
+    documents.forEach(function (doc) {
+      doc.definitions.forEach(function (definition) {
+        if (isExecutableDefinitionAST(definition)) {
+          astDefinitions.push(definition);
+        }
+      });
+    });
+    return convertASTDefinitions(schema, definitions, transform);
+  });
+}
+
+function convertASTDocumentsWithBase(schema, baseDocuments, documents, transform) {
+  return Profiler.run('ASTConvert.convertASTDocumentsWithBase', function () {
+    var baseDefinitions = definitionsFromDocuments(baseDocuments);
+    var definitions = definitionsFromDocuments(documents);
+    var requiredDefinitions = new Map();
+    var baseMap = new Map();
+    baseDefinitions.forEach(function (definition) {
+      if (isExecutableDefinitionAST(definition)) {
+        var definitionName = definition.name && definition.name.value; // If there's no name, no reason to put in the map
+
+        if (definitionName != null) {
+          if (baseMap.has(definitionName)) {
+            throw new Error("Duplicate definition of '".concat(definitionName, "'."));
+          }
+
+          baseMap.set(definitionName, definition);
+        }
+      }
+    });
+    var definitionsToVisit = [];
+    definitions.forEach(function (definition) {
+      if (isExecutableDefinitionAST(definition)) {
+        definitionsToVisit.push(definition);
+      }
+    });
+
+    while (definitionsToVisit.length > 0) {
+      var definition = definitionsToVisit.pop();
+      var name = definition.name && definition.name.value;
+
+      if (name == null) {
+        continue;
+      }
+
+      if (requiredDefinitions.has(name)) {
+        if (requiredDefinitions.get(name) !== definition) {
+          throw new Error("Duplicate definition of '".concat(name, "'."));
+        }
+
+        continue;
+      }
+
+      requiredDefinitions.set(name, definition);
+      visit(definition, {
+        FragmentSpread: function FragmentSpread(spread) {
+          var baseDefinition = baseMap.get(spread.name.value);
+
+          if (baseDefinition) {
+            // We only need to add those definitions not already included
+            // in definitions
+            definitionsToVisit.push(baseDefinition);
+          }
+        }
+      });
+    }
+
+    var definitionsToConvert = [];
+    requiredDefinitions.forEach(function (definition) {
+      return definitionsToConvert.push(definition);
+    });
+    return convertASTDefinitions(schema, definitionsToConvert, transform);
+  });
+}
+
+function convertASTDefinitions(schema, definitions, transform) {
+  var operationDefinitions = [];
+  definitions.forEach(function (definition) {
+    if (isExecutableDefinitionAST(definition)) {
+      operationDefinitions.push(definition);
+    }
+  });
+  return transform(schema, operationDefinitions);
+}
+
+function definitionsFromDocuments(documents) {
+  var definitions = [];
+  documents.forEach(function (doc) {
+    doc.definitions.forEach(function (definition) {
+      return definitions.push(definition);
+    });
+  });
+  return definitions;
+}
+/**
+ * Extends a GraphQLSchema with a list of schema extensions in string form.
+ */
+
+
+function transformASTSchema(schema, schemaExtensions) {
+  return Profiler.run('ASTConvert.transformASTSchema', function () {
+    if (schemaExtensions.length === 0) {
+      return schema;
+    }
+
+    var extension = schemaExtensions.join('\n');
+    return cachedExtend(schema, extension, function () {
+      return extendSchema(schema, parse(extension));
+    });
+  });
+}
+/**
+ * Extends a GraphQLSchema with a list of schema extensions in AST form.
+ */
+
+
+function extendASTSchema(baseSchema, documents) {
+  return Profiler.run('ASTConvert.extendASTSchema', function () {
+    var schemaExtensions = [];
+    documents.forEach(function (doc) {
+      doc.definitions.forEach(function (definition) {
+        if (isSchemaDefinitionAST(definition)) {
+          schemaExtensions.push(definition);
+        }
+      });
+    });
+
+    if (schemaExtensions.length === 0) {
+      return baseSchema;
+    }
+
+    var key = schemaExtensions.map(print).join('\n');
+    return cachedExtend(baseSchema, key, function () {
+      return extendSchema(baseSchema, {
+        kind: 'Document',
+        definitions: schemaExtensions
+      }, // TODO T24511737 figure out if this is dangerous
+      {
+        assumeValid: true
+      });
+    });
+  });
+}
+
+var extendedSchemas = new Map();
+
+function cachedExtend(schema, key, compute) {
+  var cache = extendedSchemas.get(schema);
+
+  if (!cache) {
+    cache = {};
+    extendedSchemas.set(schema, cache);
+  }
+
+  var extendedSchema = cache[key];
+
+  if (!extendedSchema) {
+    extendedSchema = compute();
+    cache[key] = extendedSchema;
+  }
+
+  return extendedSchema;
+}
+
+module.exports = {
+  convertASTDocuments: convertASTDocuments,
+  convertASTDocumentsWithBase: convertASTDocumentsWithBase,
+  extendASTSchema: extendASTSchema,
+  transformASTSchema: transformASTSchema
+};

package/lib/core/CompilerContext.js

@@ -0,0 +1,165 @@
+/**
+ * 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 Profiler = require('./GraphQLCompilerProfiler');
+
+var invariant = require('invariant');
+
+var _require = require('./CompilerError'),
+    createUserError = _require.createUserError; // $FlowFixMe[untyped-import] - immutable.js is not flow-typed
+
+
+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 CompilerContext = /*#__PURE__*/function () {
+  // $FlowFixMe[value-as-type]
+  function CompilerContext(schema) {
+    this._isMutable = false;
+    this._documents = new ImmutableOrderedMap();
+    this._withTransform = new WeakMap();
+    this._schema = schema;
+  }
+  /**
+   * Returns the documents for the context in the order they were added.
+   */
+
+
+  var _proto = CompilerContext.prototype;
+
+  _proto.documents = function documents() {
+    return this._documents.toArray();
+  };
+
+  _proto.forEachDocument = function forEachDocument(fn) {
+    this._documents.forEach(fn);
+  };
+
+  _proto.replace = function replace(node) {
+    return this._update(this._documents.update(node.name, function (existing) {
+      !existing ? process.env.NODE_ENV !== "production" ? invariant(false, 'CompilerContext: Expected to replace existing node %s, but ' + 'one was not found in the context.', node.name) : invariant(false) : void 0;
+      return node;
+    }));
+  };
+
+  _proto.add = function add(node) {
+    return this._update(this._documents.update(node.name, function (existing) {
+      !!existing ? process.env.NODE_ENV !== "production" ? invariant(false, 'CompilerContext: Duplicate document named `%s`. GraphQL ' + 'fragments and roots must have unique names.', node.name) : invariant(false) : void 0;
+      return node;
+    }));
+  };
+
+  _proto.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.
+   */
+  ;
+
+  _proto.applyTransforms = function applyTransforms(transforms, reporter) {
+    var _this = this;
+
+    return Profiler.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.
+   */
+  ;
+
+  _proto.applyTransform = function applyTransform(transform, reporter) {
+    var transformed = this._withTransform.get(transform);
+
+    if (!transformed) {
+      var start = process.hrtime();
+      transformed = Profiler.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;
+  };
+
+  _proto.get = function get(name) {
+    return this._documents.get(name);
+  };
+
+  _proto.getFragment = function getFragment(name, referencedFrom) {
+    var node = this._documents.get(name);
+
+    if (node == null) {
+      throw createUserError("Cannot find fragment '".concat(name, "'."), referencedFrom != null ? [referencedFrom] : null);
+    } else if (node.kind !== 'Fragment') {
+      throw createUserError("Cannot find fragment '".concat(name, "', a document with this name exists ") + 'but is not a fragment.', [node.loc, referencedFrom].filter(Boolean));
+    }
+
+    return node;
+  };
+
+  _proto.getRoot = function getRoot(name) {
+    var node = this._documents.get(name);
+
+    if (node == null) {
+      throw createUserError("Cannot find root '".concat(name, "'."));
+    } else if (node.kind !== 'Root') {
+      throw createUserError("Cannot find root '".concat(name, "', a document with this name exists but ") + 'is not a root.', [node.loc]);
+    }
+
+    return node;
+  };
+
+  _proto.remove = function remove(name) {
+    return this._update(this._documents["delete"](name));
+  };
+
+  _proto.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;
+  };
+
+  _proto._update = function _update(documents) {
+    var context = this._isMutable ? this : new CompilerContext(this.getSchema());
+    context._documents = documents;
+    return context;
+  };
+
+  _proto.getSchema = function getSchema() {
+    return this._schema;
+  };
+
+  return CompilerContext;
+}();
+
+module.exports = CompilerContext;