relay-compiler 11.0.0-rc.0 → 12.0.0

package/runner/BufferedFilesystem.js.flow

@@ -144,7 +144,7 @@ class BufferedFilesystem implements Filesystem {
     return fs.readFileSync(path, encoding);
   }
 
-  statSync(path: string): {isDirectory(): boolean, ...} {
+  statSync(path: string): interface {isDirectory(): boolean} {
     this._assertNotComitted();
     return fs.statSync(path);
   }

package/transforms/ClientExtensionsTransform.js.flow

@@ -31,6 +31,7 @@ function clientExtensionTransform(context: CompilerContext): CompilerContext {
 }
 
 function traverseDefinition<T: Definition>(node: T): T {
+  // $FlowFixMe[incompatible-use]
   const compilerContext: CompilerContext = this.getContext();
 
   const schema = compilerContext.getSchema();

package/transforms/ConnectionTransform.js.flow

@@ -123,6 +123,7 @@ function visitFragmentOrRoot<N: Fragment | Root>(
   node: N,
   options: Options,
 ): ?N {
+  // $FlowFixMe[incompatible-use]
   const transformedNode = this.traverse(node, options);
   const connectionMetadata = options.connectionMetadata;
   if (connectionMetadata.length) {
@@ -141,6 +142,7 @@ function visitFragmentOrRoot<N: Fragment | Root>(
  * @internal
  */
 function visitLinkedField(field: LinkedField, options: Options): LinkedField {
+  // $FlowFixMe[incompatible-use]
   const context: CompilerContext = this.getContext();
   const schema = context.getSchema();
 
@@ -148,6 +150,7 @@ function visitLinkedField(field: LinkedField, options: Options): LinkedField {
 
   const isPlural = schema.isList(nullableType);
   const path = options.path.concat(isPlural ? null : field.alias || field.name);
+  // $FlowFixMe[incompatible-use]
   let transformedField: LinkedField = this.traverse(field, {
     ...options,
     path,
@@ -198,6 +201,7 @@ function visitLinkedField(field: LinkedField, options: Options): LinkedField {
   const {direction} = connectionMetadata;
   if (direction != null) {
     const selections = transformConnectionSelections(
+      // $FlowFixMe[incompatible-use]
       this.getContext(),
       transformedField,
       schema.assertCompositeType(nullableType),

package/transforms/DeclarativeConnectionMutationTransform.js.flow

@@ -94,6 +94,7 @@ function visitScalarField(field: ScalarField): ScalarField {
     return field;
   }
 
+  // $FlowFixMe[incompatible-use]
   const schema = this.getContext().getSchema();
 
   if (!schema.isId(schema.getRawType(field.type))) {
@@ -126,6 +127,7 @@ function visitScalarField(field: ScalarField): ScalarField {
 }
 
 function visitLinkedField(field: LinkedField): LinkedField {
+  // $FlowFixMe[incompatible-use]
   const transformedField = this.traverse(field);
   const deleteDirective = transformedField.directives.find(
     directive => directive.name === DELETE_RECORD,
@@ -162,6 +164,7 @@ function visitLinkedField(field: LinkedField): LinkedField {
       [targetDirective.loc],
     );
   }
+  // $FlowFixMe[incompatible-use]
   const schema = this.getContext().getSchema();
   if (edgeDirective) {
     const fieldType = schema.getRawType(transformedField.type);

package/transforms/DeferStreamTransform.js.flow

@@ -156,6 +156,7 @@ function visitScalarField(field: ScalarField, state: State): ScalarField {
       [streamDirective.loc],
     );
   }
+  // $FlowFixMe[incompatible-use]
   return this.traverse(field, state);
 }
 

package/transforms/DisallowIdAsAlias.js.flow

@@ -28,6 +28,7 @@ function visitField<T: ScalarField | LinkedField>(field: T): T {
       [field.loc],
     );
   }
+  // $FlowFixMe[incompatible-use]
   return this.traverse(field);
 }
 

package/transforms/FieldHandleTransform.js.flow

@@ -34,6 +34,7 @@ function fieldHandleTransform(context: CompilerContext): CompilerContext {
  * @internal
  */
 function visitField<F: LinkedField | ScalarField>(field: F): F {
+  // $FlowFixMe[incompatible-use]
   const nextField = field.kind === 'LinkedField' ? this.traverse(field) : field;
   const handles = nextField.handles;
   if (!handles || !handles.length) {
@@ -46,6 +47,7 @@ function visitField<F: LinkedField | ScalarField>(field: F): F {
       '"handle" property, got `%s`.',
     handles.join(', '),
   );
+  // $FlowFixMe[incompatible-use]
   const context: CompilerContext = this.getContext();
   const schema = context.getSchema();
   const alias = nextField.alias;

package/transforms/FlattenTransform.js.flow

@@ -14,7 +14,7 @@
 
 const IRTransformer = require('../core/IRTransformer');
 
-const areEqual = require('../util/areEqualOSS');
+const areEqualArgValues = require('../util/areEqualArgValues');
 const getIdentifierForSelection = require('../core/getIdentifierForSelection');
 
 const {createCompilerError, createUserError} = require('../core/CompilerError');
@@ -74,6 +74,7 @@ function flattenTransformImpl(
 
 function memoizedFlattenSelection(cache: Map<Node, Map<?TypeID, any>>) {
   return function flattenSelectionsFn<T: Node>(node: T, state: State): T {
+    // $FlowFixMe[incompatible-use]
     const context: CompilerContext = this.getContext();
     let nodeCache = cache.get(node);
     if (nodeCache == null) {
@@ -117,6 +118,7 @@ function memoizedFlattenSelection(cache: Map<Node, Map<?TypeID, any>>) {
       ? {...node, selections: Array.from(nextSelections.values())}
       : node;
     state.parentType = type;
+    // $FlowFixMe[incompatible-use]
     const deeplyFlattenedNode = this.traverse(flattenedNode, state);
     state.parentType = parentType;
     nodeCache.set(parentType, deeplyFlattenedNode);
@@ -415,7 +417,10 @@ function areEqualArgs(
         thisArg.value.kind === thatArg.value.kind &&
         (thisArg.value: any).variableName ===
           (thatArg.value: any).variableName &&
-        areEqual((thisArg.value: any).value, (thatArg.value: any).value)
+        areEqualArgValues(
+          (thisArg.value: any).value,
+          (thatArg.value: any).value,
+        )
       );
     })
   );
@@ -436,8 +441,11 @@ function mergeHandles<T: LinkedField | ScalarField>(
   }
   const uniqueItems = new Map();
   nodeA.handles
+    // $FlowFixMe[incompatible-use]
     .concat(nodeB.handles)
+    // $FlowFixMe[incompatible-use]
     .forEach(item => uniqueItems.set(item.name + item.key, item));
+  // $FlowFixMe[incompatible-return]
   return Array.from(uniqueItems.values());
 }
 

package/transforms/GenerateIDFieldTransform.js.flow

@@ -77,6 +77,7 @@ function generateIDFieldTransform(context: CompilerContext): CompilerContext {
 }
 
 function visitLinkedField(field: LinkedField, state: State): LinkedField {
+  // $FlowFixMe[incompatible-use]
   const transformedNode = this.traverse(field, state);
 
   // If the field already has an unaliased `id` field, do nothing
@@ -84,6 +85,7 @@ function visitLinkedField(field: LinkedField, state: State): LinkedField {
     return transformedNode;
   }
 
+  // $FlowFixMe[incompatible-use]
   const context: CompilerContext = this.getContext();
   const schema = context.getSchema();
   const unmodifiedType = schema.assertCompositeType(

package/transforms/GenerateTypeNameTransform.js.flow

@@ -69,8 +69,10 @@ function generateTypeNameTransform(context: CompilerContext): CompilerContext {
 }
 
 function visitFragment(fragment: Fragment, state: State): Fragment {
+  // $FlowFixMe[incompatible-use]
   const schema: Schema = this.getContext().getSchema();
   const rawType = schema.getRawType(fragment.type);
+  // $FlowFixMe[incompatible-use]
   let transformedNode = (this.traverse(fragment, state): Fragment);
   const isClientType = !schema.isServerType(rawType);
   if (!isClientType && schema.isAbstractType(rawType)) {
@@ -102,12 +104,14 @@ function visitInlineFragment(
   fragment: InlineFragment,
   state: State,
 ): InlineFragment {
+  // $FlowFixMe[incompatible-use]
   const schema: Schema = this.getContext().getSchema();
   let transformedNode = cache.get(fragment);
   if (transformedNode != null && transformedNode.kind === 'InlineFragment') {
     return transformedNode;
   }
   const rawType = schema.getRawType(fragment.typeCondition);
+  // $FlowFixMe[incompatible-use]
   transformedNode = (this.traverse(fragment, state): InlineFragment);
   const isClientType = !schema.isServerType(rawType);
   if (!isClientType && schema.isAbstractType(rawType)) {
@@ -137,11 +141,13 @@ function visitInlineFragment(
 }
 
 function visitLinkedField(field: LinkedField, state: State): LinkedField {
+  // $FlowFixMe[incompatible-use]
   const schema: Schema = this.getContext().getSchema();
   let transformedNode = cache.get(field);
   if (transformedNode != null && transformedNode.kind === 'LinkedField') {
     return transformedNode;
   }
+  // $FlowFixMe[incompatible-use]
   transformedNode = (this.traverse(field, state): LinkedField);
   if (
     schema.isAbstractType(schema.getRawType(transformedNode.type)) &&

package/transforms/InlineDataFragmentTransform.js.flow

@@ -44,6 +44,7 @@ function inlineDataFragmentTransform(
 }
 
 function visitFragment(fragment: Fragment): Fragment {
+  // $FlowFixMe[incompatible-use]
   const transformedFragment = this.traverse(fragment);
 
   const inlineDirective = transformedFragment.directives.find(
@@ -67,10 +68,12 @@ function visitFragment(fragment: Fragment): Fragment {
 function visitFragmentSpread(
   fragmentSpread: FragmentSpread,
 ): FragmentSpread | InlineDataFragmentSpread {
+  // $FlowFixMe[incompatible-use]
   const transformedFragmentSpread: FragmentSpread = this.traverse(
     fragmentSpread,
   );
 
+  // $FlowFixMe[incompatible-use]
   const context: CompilerContext = this.getContext();
   const fragment = context.get(transformedFragmentSpread.name);
   if (
@@ -99,6 +102,7 @@ function visitFragmentSpread(
     );
   }
 
+  // $FlowFixMe[incompatible-use]
   const transformedFragment = (this.visit(fragment): Fragment);
 
   return ({

package/transforms/InlineFragmentsTransform.js.flow

@@ -48,6 +48,7 @@ function fragmentSpreadVisitor(cache: FragmentVisitorCache): FragmentVisitor {
         'arguments. Use the `ApplyFragmentArgumentTransform` before flattening',
       fragmentSpread.name,
     );
+    // $FlowFixMe[incompatible-use]
     const fragment: Fragment = this.getContext().getFragment(
       fragmentSpread.name,
       fragmentSpread.loc,
@@ -60,6 +61,7 @@ function fragmentSpreadVisitor(cache: FragmentVisitorCache): FragmentVisitor {
       selections: fragment.selections,
       typeCondition: fragment.type,
     };
+    // $FlowFixMe[incompatible-use]
     traverseResult = this.traverse(result);
     cache.set(fragmentSpread, traverseResult);
     return traverseResult;

package/transforms/MaskTransform.js.flow

@@ -47,11 +47,13 @@ function maskTransform(context: CompilerContext): CompilerContext {
 }
 
 function visitFragment(fragment: Fragment, state: State): Fragment {
+  // $FlowFixMe[incompatible-use]
   const result = this.traverse(fragment, state);
   if (state.reachableArguments.length === 0) {
     return result;
   }
   const joinedArgumentDefinitions = joinArgumentDefinitions(
+    // $FlowFixMe[incompatible-use]
     this.getContext().getSchema(),
     fragment,
     state.reachableArguments,
@@ -76,6 +78,7 @@ function visitFragmentSpread(
       'arguments. Use the `ApplyFragmentArgumentTransform` before flattening',
     fragmentSpread.name,
   );
+  // $FlowFixMe[incompatible-use]
   const context = this.getContext();
   const fragment: Fragment = context.getFragment(fragmentSpread.name);
   const result: InlineFragment = {
@@ -111,6 +114,7 @@ function visitFragmentSpread(
   for (const argDef of fragment.argumentDefinitions) {
     state.reachableArguments.push(argDef);
   }
+  // $FlowFixMe[incompatible-use]
   return this.traverse(result, state);
 }
 

package/transforms/MatchTransform.js.flow

@@ -91,6 +91,7 @@ function visitInlineFragment(
   node: InlineFragment,
   state: State,
 ): InlineFragment {
+  // $FlowFixMe[incompatible-use]
   return this.traverse(node, {
     ...state,
     parentType: node.typeCondition,
@@ -98,6 +99,7 @@ function visitInlineFragment(
 }
 
 function visitScalarField(field: ScalarField): ScalarField {
+  // $FlowFixMe[incompatible-use]
   const context: CompilerContext = this.getContext();
   const schema = context.getSchema();
 
@@ -125,6 +127,7 @@ function visitScalarField(field: ScalarField): ScalarField {
 }
 
 function visitLinkedField(node: LinkedField, state: State): LinkedField {
+  // $FlowFixMe[incompatible-use]
   const context: CompilerContext = this.getContext();
   const schema = context.getSchema();
 
@@ -153,6 +156,7 @@ function visitLinkedField(node: LinkedField, state: State): LinkedField {
   }
 
   state.path.push(node);
+  // $FlowFixMe[incompatible-use]
   const transformedNode: LinkedField = this.traverse(node, {
     ...state,
     moduleKey,

package/transforms/ReactFlightComponentTransform.js.flow

@@ -70,6 +70,7 @@ function reactFlightComponentTransform(
 }
 
 function visitInlineFragment(fragment, state) {
+  // $FlowFixMe[incompatible-use]
   return this.traverse(fragment, {
     parentType: fragment.typeCondition ?? state.parentType,
     types: state.types,
@@ -77,11 +78,13 @@ function visitInlineFragment(fragment, state) {
 }
 
 function visitLinkedField(field, state) {
+  // $FlowFixMe[incompatible-use]
   return this.traverse(field, {parentType: field.type, types: state.types});
 }
 
 function visitScalarField(field: ScalarField, state: State): ScalarField {
   // use the return type to quickly determine if this is a flight field
+  // $FlowFixMe[incompatible-use]
   const schema = this.getContext().getSchema();
   if (schema.getRawType(field.type) !== state.types.componentType) {
     return field;

package/transforms/RelayDirectiveTransform.js.flow

@@ -49,10 +49,12 @@ function visitRelayMetadata<T: Fragment | FragmentSpread>(
   return function(node) {
     const relayDirective = node.directives.find(({name}) => name === RELAY);
     if (!relayDirective) {
+      // $FlowFixMe[incompatible-use]
       return this.traverse(node);
     }
     const argValues = getLiteralArgumentValues(relayDirective.args);
     const metadata = metadataFn(argValues);
+    // $FlowFixMe[incompatible-use]
     return this.traverse({
       ...node,
       directives: node.directives.filter(

package/transforms/RequiredFieldTransform.js.flow

@@ -95,10 +95,12 @@ function requiredFieldTransform(context: CompilerContext): CompilerContext {
 }
 
 function visitFragment(fragment: Fragment, state: State) {
+  // $FlowFixMe[incompatible-use]
   return addChildrenCanBubbleMetadata(this.traverse(fragment, state), state);
 }
 
 function visitRoot(root: Root, state: State) {
+  // $FlowFixMe[incompatible-use]
   return addChildrenCanBubbleMetadata(this.traverse(root, state), state);
 }
 
@@ -110,6 +112,7 @@ function visitInlineFragment(fragment: InlineFragment, state: State) {
     state.parentAbstractInlineFragment ??
     getAbstractInlineFragment(fragment, state.schema);
 
+  // $FlowFixMe[incompatible-use]
   return this.traverse(fragment, {...state, parentAbstractInlineFragment});
 }
 
@@ -148,6 +151,7 @@ function visitLinkedField(field: LinkedField, state: State): LinkedField {
     parentAbstractInlineFragment: null,
   };
 
+  // $FlowFixMe[incompatible-use]
   let newField = this.traverse(field, newState);
 
   const pathName = path.join('.');

package/transforms/SkipClientExtensionsTransform.js.flow

@@ -28,14 +28,17 @@ function skipClientExtensionTransform(
 }
 
 function visitFragment(node: Fragment): ?Fragment {
+  // $FlowFixMe[incompatible-use]
   const context: CompilerContext = this.getContext();
   if (context.getSchema().isServerType(node.type)) {
+    // $FlowFixMe[incompatible-use]
     return this.traverse(node);
   }
   return null;
 }
 
 function vistFragmentSpread(node: FragmentSpread): ?FragmentSpread {
+  // $FlowFixMe[incompatible-use]
   const context: CompilerContext = this.getContext();
   const fragment = context.getFragment(node.name, node.loc);
   const isServer = context.getSchema().isServerType(fragment.type);

package/transforms/SkipHandleFieldTransform.js.flow

@@ -29,6 +29,7 @@ function skipHandleFieldTransform(context: CompilerContext): CompilerContext {
 }
 
 function visitField<F: Field>(field: F): ?F {
+  // $FlowFixMe[incompatible-use]
   const transformedNode = this.traverse(field);
   if (transformedNode.handles) {
     return {

package/transforms/SkipRedundantNodesTransform.js.flow

@@ -137,6 +137,7 @@ function skipRedundantNodesTransform(
 let cache = new Map();
 function visitNode<T: Fragment | Root | SplitOperation>(node: T): ?T {
   cache = new Map();
+  // $FlowFixMe[incompatible-use]
   const context: CompilerContext = this.getContext();
   return transformNode(context.getSchema(), node, new IMap()).node;
 }
@@ -234,6 +235,7 @@ function transformNode<T: Node>(
     // $FlowFixMe[escaped-generic]
     cache.set(node, result);
   }
+  // $FlowFixMe[incompatible-return]
   return result;
 }
 

package/transforms/SplitModuleImportTransform.js.flow

@@ -51,6 +51,7 @@ function splitMatchTransform(context: CompilerContext): CompilerContext {
 }
 
 function visitLinkedField(field: LinkedField, state: State): LinkedField {
+  // $FlowFixMe[incompatible-use]
   return this.traverse(field, {
     parentType: field.type,
     splitOperations: state.splitOperations,
@@ -61,6 +62,7 @@ function visitInlineFragment(
   fragment: InlineFragment,
   state: State,
 ): InlineFragment {
+  // $FlowFixMe[incompatible-use]
   return this.traverse(fragment, {
     parentType: fragment.typeCondition,
     splitOperations: state.splitOperations,
@@ -77,6 +79,7 @@ function visitModuleImport(node: ModuleImport, state: State): ModuleImport {
     createdSplitOperation.parentSources.add(node.sourceDocument);
     return node;
   }
+  // $FlowFixMe[incompatible-use]
   const transformedNode = this.traverse(node, state);
   const splitOperation: SplitOperation = {
     kind: 'SplitOperation',

package/transforms/TestOperationTransform.js.flow

@@ -57,6 +57,7 @@ function getTypeDetails(schema: Schema, fieldType: TypeID): TypeDetails {
 }
 
 function visitRoot(node: Root) {
+  // $FlowFixMe[incompatible-use]
   const schema: Schema = this.getContext().getSchema();
   const testDirective = node.directives.find(
     directive => directive.name === 'relay_test_operation',

package/transforms/ValidateRequiredArgumentsTransform.js.flow

@@ -51,6 +51,7 @@ function validateRequiredArguments(context: CompilerContext): CompilerContext {
 }
 
 function visitDirective(node: Directive, {rootNode}: State): void {
+  // $FlowFixMe[incompatible-use]
   const context: CompilerContext = this.getContext();
   const directiveDef = context.getSchema().getDirective(node.name);
   if (directiveDef == null) {
@@ -65,6 +66,7 @@ function visitDirective(node: Directive, {rootNode}: State): void {
 }
 
 function visitInlineFragment(fragment, {rootNode}: State): void {
+  // $FlowFixMe[incompatible-use]
   this.traverse(fragment, {
     rootNode,
     parentType: fragment.typeCondition,
@@ -72,6 +74,7 @@ function visitInlineFragment(fragment, {rootNode}: State): void {
 }
 
 function visitField(node: Field, {parentType, rootNode}: State): void {
+  // $FlowFixMe[incompatible-use]
   const context: CompilerContext = this.getContext();
   const schema = context.getSchema();
   const definition = getFieldDefinitionStrict(schema, parentType, node.name);
@@ -94,6 +97,7 @@ function visitField(node: Field, {parentType, rootNode}: State): void {
       rootNode,
     );
   }
+  // $FlowFixMe[incompatible-use]
   this.traverse(node, {
     rootNode,
     parentType: node.type,

package/transforms/ValidateServerOnlyDirectivesTransform.js.flow

@@ -61,12 +61,14 @@ function stopVisit() {}
 // Only visits selections as an optimization to not look at arguments
 function visitLinkedField(node: LinkedField, state: State): void {
   for (const selection of node.selections) {
+    // $FlowFixMe[incompatible-use]
     this.visit(selection, state);
   }
 }
 
 function visitClientExtension(node: ClientExtension, state: State): void {
   for (const selection of node.selections) {
+    // $FlowFixMe[incompatible-use]
     this.visit(selection, {
       rootClientSelection: selection,
     });
@@ -92,6 +94,7 @@ function visitTransformedDirective(node: Defer | Stream, state: State): void {
         : null,
     );
   }
+  // $FlowFixMe[incompatible-use]
   this.traverse(node, state);
 }
 

package/util/{areEqualOSS.js.flow → areEqualArgValues.js.flow}

@@ -8,6 +8,8 @@
  * @format
  */
 
+// TODO: This is only used with `ArgumentValue` types, so it could be simpler.
+
 // flowlint ambiguous-object-type:error
 'use strict';
 
@@ -22,7 +24,7 @@ const bStackPool = [];
  * @copyright 2009-2013 Jeremy Ashkenas, DocumentCloud Inc.
  * @license MIT
  */
-function areEqual(a: any, b: any): boolean {
+function areEqualArgValues(a: any, b: any): boolean {
   const aStack = aStackPool.length ? aStackPool.pop() : [];
   const bStack = bStackPool.length ? bStackPool.pop() : [];
   const result = eq(a, b, aStack, bStack);
@@ -45,6 +47,7 @@ function eq(a: any, b: any, aStack: Array<any>, bStack: Array<any>): boolean {
   if (typeof a !== 'object' || typeof b !== 'object') {
     return false;
   }
+  // $FlowFixMe[method-unbinding] added when improving typing for this parameters
   const objToStr = Object.prototype.toString;
   const className = objToStr.call(a);
   if (className !== objToStr.call(b)) {
@@ -104,7 +107,7 @@ function eq(a: any, b: any, aStack: Array<any>, bStack: Array<any>): boolean {
         // HACK: Comparing deeply nested React trees is slow since you end up
         // comparing the entire tree (all ancestors and all children) and
         // likely not what you want if you're comparing two elements with
-        // areEqual. We bail out here for now.
+        // areEqualArgValues. We bail out here for now.
         continue;
       }
       if (
@@ -120,4 +123,4 @@ function eq(a: any, b: any, aStack: Array<any>, bStack: Array<any>): boolean {
   return true;
 }
 
-module.exports = areEqual;
+module.exports = areEqualArgValues;