relay-compiler 8.0.0 → 10.0.1

package/codegen/writeRelayGeneratedFile.js.flow

@@ -0,0 +1,223 @@
+/**
+ * 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.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+const CodeMarker = require('../util/CodeMarker');
+
+const createPrintRequireModuleDependency = require('./createPrintRequireModuleDependency');
+const dedupeJSONStringify = require('../util/dedupeJSONStringify');
+const invariant = require('invariant');
+const md5 = require('../util/md5');
+
+const {RelayConcreteNode} = require('relay-runtime');
+
+import type {GeneratedDefinition} from '../core/IR';
+import type {Schema} from '../core/Schema';
+import type {
+  FormatModule,
+  PluginInterface,
+} from '../language/RelayLanguagePluginInterface';
+import type CodegenDirectory from './CodegenDirectory';
+import type {GeneratedNode, RequestParameters} from 'relay-runtime';
+
+function getConcreteType(node: GeneratedNode): string {
+  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: empty);
+      invariant(false, 'Unexpected GeneratedNode kind: `%s`.', node.kind);
+  }
+}
+
+function writeRelayGeneratedFile(
+  schema: Schema,
+  codegenDir: CodegenDirectory,
+  definition: GeneratedDefinition,
+  _generatedNode: GeneratedNode,
+  formatModule: FormatModule,
+  typeText: string,
+  _persistQuery: ?(text: string) => Promise<string>,
+  sourceHash: string,
+  extension: string,
+  printModuleDependency: (
+    moduleName: string,
+  ) => string = createPrintRequireModuleDependency(extension),
+  shouldRepersist: boolean,
+  writeQueryParameters: (
+    dir: CodegenDirectory,
+    filename: string,
+    moduleName: string,
+    params: RequestParameters,
+  ) => void,
+  languagePlugin: ?PluginInterface,
+): Promise<?GeneratedNode> {
+  let generatedNode = _generatedNode;
+  // Copy to const so Flow can refine.
+  const persistQuery = _persistQuery;
+  const operationName =
+    generatedNode.kind === 'Request'
+      ? generatedNode.params.name
+      : generatedNode.name;
+  const moduleName = languagePlugin?.getModuleName
+    ? languagePlugin.getModuleName(operationName)
+    : operationName + '.graphql';
+
+  const filename = moduleName + '.' + extension;
+  const queryParametersFilename =
+    generatedNode.kind === 'Request'
+      ? `${generatedNode.params.name}$Parameters.${extension}`
+      : null;
+
+  const typeName = getConcreteType(generatedNode);
+
+  let 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(async () => {
+    let hash = null;
+    if (generatedNode.kind === RelayConcreteNode.REQUEST) {
+      invariant(
+        docText != null,
+        'writeRelayGeneratedFile: Expected `text` for operations to be set.',
+      );
+
+      const {
+        isRefetchableQuery: _ignored,
+        derivedFrom: _ignored2,
+        ...nextMetadata
+      } = generatedNode.params.metadata;
+
+      let nextRequestParams;
+      if (persistQuery != null) {
+        hash = md5(docText);
+
+        let 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.
+          const oldContent = codegenDir.read(filename);
+          const oldHash = extractHash(oldContent);
+          const oldRequestID = extractRelayRequestID(oldContent);
+          if (hash === oldHash && oldRequestID != null) {
+            id = oldRequestID;
+          }
+        }
+        if (id == null) {
+          id = await persistQuery(docText);
+        }
+        nextRequestParams = {
+          id,
+          metadata: nextMetadata,
+          name: generatedNode.params.name,
+          operationKind: generatedNode.params.operationKind,
+          text: null,
+        };
+      } else {
+        nextRequestParams = {
+          cacheID: md5(docText),
+          id: null,
+          metadata: nextMetadata,
+          name: generatedNode.params.name,
+          operationKind: generatedNode.params.operationKind,
+          text: docText,
+        };
+      }
+      generatedNode = {
+        ...generatedNode,
+        params: nextRequestParams,
+      };
+    }
+
+    // Strip metadata only used within the compiler
+    if (
+      generatedNode.kind === RelayConcreteNode.SPLIT_OPERATION &&
+      generatedNode.metadata?.derivedFrom != null
+    ) {
+      const {derivedFrom: _ignored, ...metadata} = generatedNode.metadata;
+      generatedNode = {
+        ...generatedNode,
+        metadata,
+      };
+    }
+
+    const moduleText = formatModule({
+      moduleName,
+      documentType: typeName,
+      definition,
+      kind: generatedNode.kind,
+      docText,
+      typeText,
+      hash: hash != null ? `@relayHash ${hash}` : null,
+      concreteText: CodeMarker.postProcess(
+        dedupeJSONStringify(generatedNode),
+        printModuleDependency,
+      ),
+      sourceHash,
+      node: generatedNode,
+      schema,
+    });
+    codegenDir.writeFile(filename, moduleText, shouldRepersist);
+    if (
+      writeQueryParameters &&
+      queryParametersFilename != null &&
+      generatedNode.kind === RelayConcreteNode.REQUEST &&
+      generatedNode.params.operationKind === 'query'
+    ) {
+      writeQueryParameters(
+        codegenDir,
+        queryParametersFilename,
+        moduleName,
+        generatedNode.params,
+      );
+    }
+    return generatedNode;
+  });
+}
+
+function extractHash(text: ?string): ?string {
+  if (text == null || text.length === 0) {
+    return null;
+  }
+  if (/<<<<<|>>>>>/.test(text)) {
+    // looks like a merge conflict
+    return null;
+  }
+  const match = text.match(/@relayHash (\w{32})\b/m);
+  return match && match[1];
+}
+
+function extractRelayRequestID(text: ?string): ?string {
+  if (text == null || text.length === 0) {
+    return null;
+  }
+  if (/<<<<<|>>>>>/.test(text)) {
+    // looks like a merge conflict
+    return null;
+  }
+  const match = text.match(/@relayRequestID (.+)/);
+  return match ? match[1] : null;
+}
+
+module.exports = writeRelayGeneratedFile;

package/core/ASTCache.js.flow

@@ -0,0 +1,73 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+const Profiler = require('./GraphQLCompilerProfiler');
+
+// $FlowFixMe[untyped-import] : Immutable is not typed
+const {Map: ImmutableMap} = require('immutable');
+
+import type {File} from '../codegen/CodegenTypes';
+import type {DocumentNode} from 'graphql';
+
+type ParseFn = (baseDir: string, file: File) => ?DocumentNode;
+
+class ASTCache {
+  _documents: Map<string, DocumentNode>;
+
+  _baseDir: string;
+  _parse: ParseFn;
+
+  constructor(config: {baseDir: string, parse: ParseFn, ...}) {
+    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
+  documents(): ImmutableMap<string, DocumentNode> {
+    return ImmutableMap(this._documents);
+  }
+
+  // parse should return the set of changes
+  parseFiles(files: Set<File>): ImmutableMap<string, DocumentNode> {
+    let documents = ImmutableMap();
+
+    files.forEach(file => {
+      if (!file.exists) {
+        this._documents.delete(file.relPath);
+        return;
+      }
+
+      const doc = (() => {
+        try {
+          return this._parse(this._baseDir, file);
+        } catch (error) {
+          throw new Error(`Parse error: ${error} in "${file.relPath}"`);
+        }
+      })();
+
+      if (!doc) {
+        this._documents.delete(file.relPath);
+        return;
+      }
+
+      documents = documents.set(file.relPath, doc);
+      this._documents.set(file.relPath, doc);
+    });
+
+    return documents;
+  }
+}
+
+module.exports = ASTCache;

package/core/ASTConvert.js.flow

@@ -0,0 +1,233 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+const Profiler = require('./GraphQLCompilerProfiler');
+
+const {
+  isExecutableDefinitionAST,
+  isSchemaDefinitionAST,
+} = require('./SchemaUtils');
+const {extendSchema, parse, print, visit} = require('graphql');
+
+import type {Fragment, Root} from './IR';
+import type {Schema} from './Schema';
+import type {
+  DefinitionNode,
+  DocumentNode,
+  FragmentDefinitionNode,
+  FragmentSpreadNode,
+  GraphQLSchema,
+  OperationDefinitionNode,
+  TypeSystemDefinitionNode,
+  TypeSystemExtensionNode,
+} from 'graphql';
+
+type ASTDefinitionNode = FragmentDefinitionNode | OperationDefinitionNode;
+type TransformFn = (
+  schema: Schema,
+  definitions: $ReadOnlyArray<ASTDefinitionNode>,
+) => $ReadOnlyArray<Root | Fragment>;
+
+function convertASTDocuments(
+  schema: Schema,
+  documents: $ReadOnlyArray<DocumentNode>,
+  transform: TransformFn,
+): $ReadOnlyArray<Fragment | Root> {
+  return Profiler.run('ASTConvert.convertASTDocuments', () => {
+    const definitions = definitionsFromDocuments(documents);
+
+    const astDefinitions: Array<ASTDefinitionNode> = [];
+    documents.forEach(doc => {
+      doc.definitions.forEach(definition => {
+        if (isExecutableDefinitionAST(definition)) {
+          astDefinitions.push(definition);
+        }
+      });
+    });
+
+    return convertASTDefinitions(schema, definitions, transform);
+  });
+}
+
+function convertASTDocumentsWithBase(
+  schema: Schema,
+  baseDocuments: $ReadOnlyArray<DocumentNode>,
+  documents: $ReadOnlyArray<DocumentNode>,
+  transform: TransformFn,
+): $ReadOnlyArray<Fragment | Root> {
+  return Profiler.run('ASTConvert.convertASTDocumentsWithBase', () => {
+    const baseDefinitions = definitionsFromDocuments(baseDocuments);
+    const definitions = definitionsFromDocuments(documents);
+
+    const requiredDefinitions = new Map();
+    const baseMap: Map<string, ASTDefinitionNode> = new Map();
+    baseDefinitions.forEach(definition => {
+      if (isExecutableDefinitionAST(definition)) {
+        const 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 '${definitionName}'.`);
+          }
+          baseMap.set(definitionName, definition);
+        }
+      }
+    });
+
+    const definitionsToVisit: Array<ASTDefinitionNode> = [];
+    definitions.forEach(definition => {
+      if (isExecutableDefinitionAST(definition)) {
+        definitionsToVisit.push(definition);
+      }
+    });
+    while (definitionsToVisit.length > 0) {
+      const definition = definitionsToVisit.pop();
+      const 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 '${name}'.`);
+        }
+        continue;
+      }
+      requiredDefinitions.set(name, definition);
+      visit(definition, {
+        FragmentSpread(spread: FragmentSpreadNode) {
+          const baseDefinition = baseMap.get(spread.name.value);
+          if (baseDefinition) {
+            // We only need to add those definitions not already included
+            // in definitions
+            definitionsToVisit.push(baseDefinition);
+          }
+        },
+      });
+    }
+
+    const definitionsToConvert = [];
+    requiredDefinitions.forEach(definition =>
+      definitionsToConvert.push(definition),
+    );
+    return convertASTDefinitions(schema, definitionsToConvert, transform);
+  });
+}
+
+function convertASTDefinitions(
+  schema: Schema,
+  definitions: $ReadOnlyArray<DefinitionNode>,
+  transform: TransformFn,
+): $ReadOnlyArray<Fragment | Root> {
+  const operationDefinitions: Array<ASTDefinitionNode> = [];
+  definitions.forEach(definition => {
+    if (isExecutableDefinitionAST(definition)) {
+      operationDefinitions.push(definition);
+    }
+  });
+  return transform(schema, operationDefinitions);
+}
+
+function definitionsFromDocuments(
+  documents: $ReadOnlyArray<DocumentNode>,
+): $ReadOnlyArray<DefinitionNode> {
+  const definitions = [];
+  documents.forEach(doc => {
+    doc.definitions.forEach(definition => definitions.push(definition));
+  });
+  return definitions;
+}
+
+/**
+ * Extends a GraphQLSchema with a list of schema extensions in string form.
+ */
+function transformASTSchema(
+  schema: GraphQLSchema,
+  schemaExtensions: $ReadOnlyArray<string>,
+): GraphQLSchema {
+  return Profiler.run('ASTConvert.transformASTSchema', () => {
+    if (schemaExtensions.length === 0) {
+      return schema;
+    }
+    const extension = schemaExtensions.join('\n');
+    return cachedExtend(schema, extension, () =>
+      extendSchema(schema, parse(extension)),
+    );
+  });
+}
+
+/**
+ * Extends a GraphQLSchema with a list of schema extensions in AST form.
+ */
+function extendASTSchema(
+  baseSchema: GraphQLSchema,
+  documents: $ReadOnlyArray<DocumentNode>,
+): GraphQLSchema {
+  return Profiler.run('ASTConvert.extendASTSchema', () => {
+    const schemaExtensions: Array<
+      TypeSystemDefinitionNode | TypeSystemExtensionNode,
+    > = [];
+    documents.forEach(doc => {
+      doc.definitions.forEach(definition => {
+        if (isSchemaDefinitionAST(definition)) {
+          schemaExtensions.push(definition);
+        }
+      });
+    });
+    if (schemaExtensions.length === 0) {
+      return baseSchema;
+    }
+    const key = schemaExtensions.map(print).join('\n');
+    return cachedExtend(baseSchema, key, () =>
+      extendSchema(
+        baseSchema,
+        {
+          kind: 'Document',
+          definitions: schemaExtensions,
+        },
+        // TODO T24511737 figure out if this is dangerous
+        {assumeValid: true},
+      ),
+    );
+  });
+}
+
+const extendedSchemas: Map<
+  GraphQLSchema,
+  {[key: string]: GraphQLSchema, ...},
+> = new Map();
+
+function cachedExtend(
+  schema: GraphQLSchema,
+  key: string,
+  compute: () => GraphQLSchema,
+): GraphQLSchema {
+  let cache = extendedSchemas.get(schema);
+  if (!cache) {
+    cache = {};
+    extendedSchemas.set(schema, cache);
+  }
+  let extendedSchema = cache[key];
+  if (!extendedSchema) {
+    extendedSchema = compute();
+    cache[key] = extendedSchema;
+  }
+  return extendedSchema;
+}
+
+module.exports = {
+  convertASTDocuments,
+  convertASTDocumentsWithBase,
+  extendASTSchema,
+  transformASTSchema,
+};

package/core/CompilerContext.js.flow

@@ -0,0 +1,190 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+const Profiler = require('./GraphQLCompilerProfiler');
+
+const invariant = require('invariant');
+
+const {createUserError} = require('./CompilerError');
+// $FlowFixMe[untyped-import] - immutable.js is not flow-typed
+const {OrderedMap: ImmutableOrderedMap} = require('immutable');
+
+import type {Reporter} from '../reporters/Reporter';
+import type {Fragment, Location, Root, SplitOperation} from './IR';
+import type {Schema} from './Schema';
+
+export type IRTransform = CompilerContext => CompilerContext;
+
+export type CompilerContextDocument = Fragment | Root | SplitOperation;
+
+/**
+ * An immutable representation of a corpus of documents being compiled together.
+ * For each document, the context stores the IR and any validation errors.
+ */
+class CompilerContext {
+  _isMutable: boolean;
+  _documents: ImmutableOrderedMap<string, CompilerContextDocument>;
+  _withTransform: WeakMap<IRTransform, CompilerContext>;
+  +_schema: Schema;
+
+  constructor(schema: 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.
+   */
+  documents(): Array<CompilerContextDocument> {
+    return this._documents.toArray();
+  }
+
+  forEachDocument(fn: CompilerContextDocument => void): void {
+    this._documents.forEach(fn);
+  }
+
+  replace(node: CompilerContextDocument): CompilerContext {
+    return this._update(
+      this._documents.update(node.name, existing => {
+        invariant(
+          existing,
+          'CompilerContext: Expected to replace existing node %s, but ' +
+            'one was not found in the context.',
+          node.name,
+        );
+        return node;
+      }),
+    );
+  }
+
+  add(node: CompilerContextDocument): CompilerContext {
+    return this._update(
+      this._documents.update(node.name, existing => {
+        invariant(
+          !existing,
+          'CompilerContext: Duplicate document named `%s`. GraphQL ' +
+            'fragments and roots must have unique names.',
+          node.name,
+        );
+        return node;
+      }),
+    );
+  }
+
+  addAll(nodes: $ReadOnlyArray<CompilerContextDocument>): CompilerContext {
+    return this.withMutations(mutable =>
+      nodes.reduce((ctx, definition) => ctx.add(definition), mutable),
+    );
+  }
+
+  /**
+   * Apply a list of compiler transforms and return a new compiler context.
+   */
+  applyTransforms(
+    transforms: $ReadOnlyArray<IRTransform>,
+    reporter?: Reporter,
+  ): CompilerContext {
+    return Profiler.run('applyTransforms', () =>
+      transforms.reduce(
+        (ctx, transform) => 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.
+   */
+  applyTransform(transform: IRTransform, reporter?: Reporter): CompilerContext {
+    let transformed = this._withTransform.get(transform);
+    if (!transformed) {
+      const start = process.hrtime();
+      transformed = Profiler.instrument(transform)(this);
+      const delta = process.hrtime(start);
+      const deltaMs = Math.round((delta[0] * 1e9 + delta[1]) / 1e6);
+      reporter && reporter.reportTime(transform.name, deltaMs);
+      this._withTransform.set(transform, transformed);
+    }
+    return transformed;
+  }
+
+  get(name: string): ?CompilerContextDocument {
+    return this._documents.get(name);
+  }
+
+  getFragment(name: string, referencedFrom?: ?Location): Fragment {
+    const node = this._documents.get(name);
+    if (node == null) {
+      throw createUserError(
+        `Cannot find fragment '${name}'.`,
+        referencedFrom != null ? [referencedFrom] : null,
+      );
+    } else if (node.kind !== 'Fragment') {
+      throw createUserError(
+        `Cannot find fragment '${name}', a document with this name exists ` +
+          'but is not a fragment.',
+        [node.loc, referencedFrom].filter(Boolean),
+      );
+    }
+    return node;
+  }
+
+  getRoot(name: string): Root {
+    const node = this._documents.get(name);
+    if (node == null) {
+      throw createUserError(`Cannot find root '${name}'.`);
+    } else if (node.kind !== 'Root') {
+      throw createUserError(
+        `Cannot find root '${name}', a document with this name exists but ` +
+          'is not a root.',
+        [node.loc],
+      );
+    }
+    return node;
+  }
+
+  remove(name: string): CompilerContext {
+    return this._update(this._documents.delete(name));
+  }
+
+  withMutations(fn: CompilerContext => CompilerContext): CompilerContext {
+    const mutableCopy = this._update(this._documents.asMutable());
+    mutableCopy._isMutable = true;
+    const result = fn(mutableCopy);
+    result._isMutable = false;
+    result._documents = result._documents.asImmutable();
+    return this._documents === result._documents ? this : result;
+  }
+
+  _update(
+    documents: ImmutableOrderedMap<string, CompilerContextDocument>,
+  ): CompilerContext {
+    const context = this._isMutable
+      ? this
+      : new CompilerContext(this.getSchema());
+    context._documents = documents;
+    return context;
+  }
+
+  getSchema(): Schema {
+    return this._schema;
+  }
+}
+
+module.exports = CompilerContext;