@ardatan/relay-compiler 12.0.0

package/core/CompilerContext.js.flow

@@ -0,0 +1,191 @@
+/**
+ * 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;
+  // $FlowFixMe[value-as-type]
+  _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;

package/core/CompilerError.js.flow

@@ -0,0 +1,255 @@
+/**
+ * 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 {GraphQLError} = require('graphql');
+
+import type {Location} from './IR';
+import type {ASTNode, Source, SourceLocation} from 'graphql';
+
+// Combined results of multiple user errors
+export opaque type CombinedUserError: Error = Error;
+
+// Error describing invalid application code from which the compiler
+// can recover, ie which does not prevent processing of other inputs.
+export opaque type UserError: Error = GraphQLError;
+
+// Error describing invalid application code from which the compiler
+// *cannot* recover, ie where the validity of subsequent inputs cannot
+// be determined. Try to avoid these errors.
+export opaque type NonRecoverableUserError: Error = Error;
+
+// Error describing a bug in the compiler
+export opaque type CompilerError: Error = Error;
+
+/**
+ * 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: string,
+  locations?: ?$ReadOnlyArray<Location>,
+  nodes?: ?$ReadOnlyArray<ASTNode>,
+): UserError {
+  let messageWithLocations = message;
+  if (locations != null) {
+    const printedLocations = printLocations(locations);
+    messageWithLocations =
+      printedLocations.length === 0
+        ? message
+        : [message, ...printedLocations].join('\n\n') + '\n';
+  }
+  return new GraphQLError(messageWithLocations, 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: string,
+  locations?: ?$ReadOnlyArray<Location>,
+  nodes?: ?$ReadOnlyArray<ASTNode>,
+): NonRecoverableUserError {
+  let messageWithLocations = message;
+  if (locations != null) {
+    const printedLocations = printLocations(locations);
+    messageWithLocations =
+      printedLocations.length === 0
+        ? message
+        : [message, ...printedLocations].join('\n\n') + '\n';
+  }
+  const error = new GraphQLError(messageWithLocations, 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: string,
+  locations?: ?$ReadOnlyArray<Location>,
+  nodes?: ?$ReadOnlyArray<ASTNode>,
+): CompilerError {
+  let messageWithLocations = message;
+  if (locations != null) {
+    const printedLocations = printLocations(locations);
+    messageWithLocations =
+      printedLocations.length === 0
+        ? message
+        : [message, ...printedLocations].join('\n\n') + '\n';
+  }
+  const error = new GraphQLError(
+    `Internal Error: ${messageWithLocations}`,
+    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<T>(iterable: Iterable<T>, fn: T => void): void {
+  const errors: Array<UserError> = [];
+  for (const item of iterable) {
+    try {
+      fn(item);
+    } catch (error) {
+      if (error instanceof GraphQLError) {
+        errors.push(error);
+      } else {
+        throw error;
+      }
+    }
+  }
+  if (errors.length > 0) {
+    if (errors.length === 1) {
+      throw createUserError(
+        String(errors[0])
+          .split('\n')
+          .map((line, index) => (index === 0 ? `- ${line}` : `  ${line}`))
+          .join('\n'),
+      );
+    }
+    throw createUserError(
+      `Encountered ${errors.length} errors:\n` +
+        errors
+          .map(error =>
+            String(error)
+              .split('\n')
+              .map((line, index) => (index === 0 ? `- ${line}` : `  ${line}`))
+              .join('\n'),
+          )
+          .join('\n'),
+    );
+  }
+}
+
+function printLocations(locations: $ReadOnlyArray<Location>): Array<string> {
+  const printedLocations = [];
+  for (const location of locations) {
+    let sourceLocation = location;
+    while (sourceLocation.kind === 'Derived') {
+      sourceLocation = sourceLocation.source;
+    }
+    switch (sourceLocation.kind) {
+      case 'Source': {
+        // source location
+        const 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: empty);
+        throw createCompilerError(
+          `CompilerError: cannot print location '${String(sourceLocation)}'.`,
+        );
+      }
+    }
+  }
+  return printedLocations;
+}
+
+/**
+ * Render a helpful description of the location of the error in the GraphQL
+ * Source document.
+ */
+function highlightSourceAtLocation(
+  source: Source,
+  location: SourceLocation,
+): string {
+  const firstLineColumnOffset = source.locationOffset.column - 1;
+  const body = whitespace(firstLineColumnOffset) + source.body;
+
+  const lineIndex = location.line - 1;
+  const lineOffset = source.locationOffset.line - 1;
+  const lineNum = location.line + lineOffset;
+
+  const columnOffset = location.line === 1 ? firstLineColumnOffset : 0;
+  const columnNum = location.column + columnOffset;
+
+  const lines = body.split(/\r\n|[\n\r]/g);
+  return (
+    `${source.name} (${lineNum}:${columnNum})\n` +
+    printPrefixedLines([
+      // Lines specified like this: ["prefix", "string"],
+      [`${lineNum - 1}: `, lines[lineIndex - 1]],
+      [`${lineNum}: `, lines[lineIndex]],
+      ['', whitespace(columnNum - 1) + '^'],
+      [`${lineNum + 1}: `, lines[lineIndex + 1]],
+    ])
+  );
+}
+
+function printPrefixedLines(lines: Array<[string, string]>): string {
+  const existingLines = lines.filter(([_, line]) => line !== undefined);
+
+  let padLen = 0;
+  for (const [prefix] of existingLines) {
+    padLen = Math.max(padLen, prefix.length);
+  }
+
+  return existingLines
+    .map(([prefix, line]) => lpad(padLen, prefix) + line)
+    .join('\n');
+}
+
+function whitespace(len: number): string {
+  return Array(len + 1).join(' ');
+}
+
+function lpad(len: number, str: string): string {
+  return whitespace(len - str.length) + str;
+}
+
+function getLocation(source: Source, position: number): SourceLocation {
+  const lineRegexp = /\r\n|[\n\r]/g;
+  let line = 1;
+  let column = position + 1;
+  let match;
+  while ((match = lineRegexp.exec(source.body)) && match.index < position) {
+    line += 1;
+    column = position + 1 - (match.index + match[0].length);
+  }
+  return {line, column};
+}
+
+module.exports = {
+  createCompilerError,
+  createNonRecoverableUserError,
+  createUserError,
+  eachWithCombinedError,
+};

package/core/DotGraphQLParser.js.flow

@@ -0,0 +1,39 @@
+/**
+ * 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 ASTCache = require('./ASTCache');
+
+const fs = require('fs');
+const path = require('path');
+
+const {parse, Source} = require('graphql');
+
+import type {File} from '../codegen/CodegenTypes';
+import type {DocumentNode} from 'graphql';
+
+function parseFile(baseDir: string, file: File): ?DocumentNode {
+  const text = fs.readFileSync(path.join(baseDir, file.relPath), 'utf8');
+  return parse(new Source(text, file.relPath), {
+    experimentalFragmentVariables: true,
+  });
+}
+
+function getParser(baseDir: string): ASTCache {
+  return new ASTCache({baseDir, parse: parseFile});
+}
+
+module.exports = {
+  parseFile,
+  getParser,
+};