relay-compiler 8.0.0 → 10.0.1

package/lib/codegen/NormalizationCodeGenerator.js

@@ -12,16 +12,27 @@
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 
-var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 
 var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+var argumentContainsVariables = require('../util/argumentContainsVariables');
+
+var generateAbstractTypeRefinementKey = require('../util/generateAbstractTypeRefinementKey');
+
+var partitionArray = require('../util/partitionArray');
+
+var sortObjectByKey = require('./sortObjectByKey');
+
 var _require = require('../core/CompilerError'),
     createCompilerError = _require.createCompilerError,
     createUserError = _require.createUserError;
 
 var _require2 = require('relay-runtime'),
-    ConnectionInterface = _require2.ConnectionInterface,
     getStorageKey = _require2.getStorageKey,
     stableCopy = _require2.stableCopy;
 
@@ -40,9 +51,9 @@ function generate(schema, node) {
 
 function generateRoot(schema, node) {
   return {
+    argumentDefinitions: generateArgumentDefinitions(schema, node.argumentDefinitions),
     kind: 'Operation',
     name: node.name,
-    argumentDefinitions: generateArgumentDefinitions(schema, node.argumentDefinitions),
     selections: generateSelections(schema, node.selections)
   };
 }
@@ -50,8 +61,8 @@ function generateRoot(schema, node) {
 function generateSplitOperation(schema, node) {
   return {
     kind: 'SplitOperation',
+    metadata: sortObjectByKey(node.metadata),
     name: node.name,
-    metadata: node.metadata,
     selections: generateSelections(schema, node.selections)
   };
 }
@@ -59,6 +70,8 @@ function generateSplitOperation(schema, node) {
 function generateSelections(schema, selections) {
   var normalizationSelections = [];
   selections.forEach(function (selection) {
+    var _selection$metadata;
+
     switch (selection.kind) {
       case 'Condition':
         normalizationSelections.push(generateCondition(schema, selection));
@@ -69,7 +82,18 @@ function generateSelections(schema, selections) {
         break;
 
       case 'ScalarField':
-        normalizationSelections.push.apply(normalizationSelections, (0, _toConsumableArray2["default"])(generateScalarField(selection)));
+        // NOTE: Inline fragments in normalization ast have the abstractKey
+        // but we skip the corresponding ScalarField for the type discriminator
+        // selection, since it's guaranteed to be a duplicate of a parent __typename
+        // selection.
+        var abstractKey = (_selection$metadata = selection.metadata) === null || _selection$metadata === void 0 ? void 0 : _selection$metadata.abstractKey;
+
+        if (typeof abstractKey === 'string') {
+          normalizationSelections.push(generateTypeDiscriminator(abstractKey));
+        } else {
+          normalizationSelections.push.apply(normalizationSelections, (0, _toConsumableArray2["default"])(generateScalarField(selection)));
+        }
+
         break;
 
       case 'ModuleImport':
@@ -84,14 +108,6 @@ function generateSelections(schema, selections) {
         normalizationSelections.push.apply(normalizationSelections, (0, _toConsumableArray2["default"])(generateLinkedField(schema, selection)));
         break;
 
-      case 'ConnectionField':
-        normalizationSelections.push.apply(normalizationSelections, (0, _toConsumableArray2["default"])(generateConnectionField(schema, selection)));
-        break;
-
-      case 'Connection':
-        normalizationSelections.push(generateConnection(schema, selection));
-        break;
-
       case 'Defer':
         normalizationSelections.push(generateDefer(schema, selection));
         break;
@@ -115,10 +131,9 @@ function generateSelections(schema, selections) {
 function generateArgumentDefinitions(schema, nodes) {
   return nodes.map(function (node) {
     return {
+      defaultValue: stableCopy(node.defaultValue),
       kind: 'LocalArgument',
-      name: node.name,
-      type: schema.getTypeString(node.type),
-      defaultValue: node.defaultValue
+      name: node.name
     };
   });
 }
@@ -136,34 +151,64 @@ function generateCondition(schema, node) {
   }
 
   return {
+    condition: node.condition.variableName,
     kind: 'Condition',
     passingValue: node.passingValue,
-    condition: node.condition.variableName,
     selections: generateSelections(schema, node.selections)
   };
 }
 
 function generateDefer(schema, node) {
   if (!(node["if"] == null || node["if"].kind === 'Variable' || node["if"].kind === 'Literal' && node["if"].value === true)) {
-    var _ref, _node$if;
+    var _node$if$loc, _node$if;
 
-    throw createCompilerError('NormalizationCodeGenerator: Expected @defer `if` condition to be ' + 'a variable, unspecified, or the literal `true`.', [(_ref = (_node$if = node["if"]) === null || _node$if === void 0 ? void 0 : _node$if.loc) !== null && _ref !== void 0 ? _ref : node.loc]);
+    throw createCompilerError('NormalizationCodeGenerator: Expected @defer `if` condition to be ' + 'a variable, unspecified, or the literal `true`.', [(_node$if$loc = (_node$if = node["if"]) === null || _node$if === void 0 ? void 0 : _node$if.loc) !== null && _node$if$loc !== void 0 ? _node$if$loc : node.loc]);
   }
 
   return {
     "if": node["if"] != null && node["if"].kind === 'Variable' ? node["if"].variableName : null,
     kind: 'Defer',
     label: node.label,
-    metadata: node.metadata,
     selections: generateSelections(schema, node.selections)
   };
 }
 
 function generateInlineFragment(schema, node) {
+  var rawType = schema.getRawType(node.typeCondition);
+  var isAbstractType = schema.isAbstractType(rawType);
+  var abstractKey = isAbstractType ? generateAbstractTypeRefinementKey(schema, rawType) : null;
+  var selections = generateSelections(schema, node.selections);
+
+  if (isAbstractType) {
+    // Maintain a few invariants:
+    // - InlineFragment (and `selections` arrays generally) cannot be empty
+    // - Don't emit a TypeDiscriminator under an InlineFragment unless it has
+    //   a different abstractKey
+    // This means we have to handle two cases:
+    // - The inline fragment only contains a TypeDiscriminator with the same
+    //   abstractKey: replace the Fragment w the Discriminator
+    // - The inline fragment contains other selections: return all the selections
+    //   minus any Discriminators w the same key
+    var _partitionArray = partitionArray(selections, function (selection) {
+      return selection.kind === 'TypeDiscriminator' && selection.abstractKey === abstractKey;
+    }),
+        discriminators = _partitionArray[0],
+        otherSelections = _partitionArray[1];
+
+    var discriminator = discriminators[0];
+
+    if (discriminator != null && otherSelections.length === 0) {
+      return discriminator;
+    } else {
+      selections = otherSelections;
+    }
+  }
+
   return {
     kind: 'InlineFragment',
-    type: schema.getTypeString(node.typeCondition),
-    selections: generateSelections(schema, node.selections)
+    selections: selections,
+    type: schema.getTypeString(rawType),
+    abstractKey: abstractKey
   };
 }
 
@@ -173,13 +218,13 @@ function generateLinkedField(schema, node) {
   // which may have originally appeared in different orders across an app.
   var handles = node.handles && node.handles.map(function (handle) {
     var handleNode = {
-      kind: 'LinkedHandle',
       alias: node.alias === node.name ? null : node.alias,
-      name: node.name,
       args: generateArgs(node.args),
+      filters: handle.filters,
       handle: handle.name,
       key: handle.key,
-      filters: handle.filters
+      kind: 'LinkedHandle',
+      name: node.name
     }; // T45504512: new connection model
     // NOTE: this intentionally adds a dynamic key in order to avoid
     // triggering updates to existing queries that do not use dynamic
@@ -187,7 +232,7 @@ function generateLinkedField(schema, node) {
 
     if (handle.dynamicKey != null) {
       var dynamicKeyArgName = '__dynamicKey';
-      handleNode = (0, _objectSpread2["default"])({}, handleNode, {
+      handleNode = _objectSpread({}, handleNode, {
         dynamicKey: {
           kind: 'Variable',
           name: dynamicKeyArgName,
@@ -196,24 +241,34 @@ function generateLinkedField(schema, node) {
       });
     }
 
+    if (handle.handleArgs != null) {
+      var handleArgs = generateArgs(handle.handleArgs);
+
+      if (handleArgs != null) {
+        handleNode = _objectSpread({}, handleNode, {
+          handleArgs: handleArgs
+        });
+      }
+    }
+
     return handleNode;
   }) || [];
   var type = schema.getRawType(node.type);
   var field = {
-    kind: 'LinkedField',
     alias: node.alias === node.name ? null : node.alias,
-    name: node.name,
-    storageKey: null,
     args: generateArgs(node.args),
     concreteType: !schema.isAbstractType(type) ? schema.getTypeString(type) : null,
+    kind: 'LinkedField',
+    name: node.name,
     plural: isPlural(schema, node.type),
-    selections: generateSelections(schema, node.selections)
+    selections: generateSelections(schema, node.selections),
+    storageKey: null
   }; // Precompute storageKey if possible
 
   var storageKey = getStaticStorageKey(field, node.metadata);
 
   if (storageKey != null) {
-    field = (0, _objectSpread2["default"])({}, field, {
+    field = _objectSpread({}, field, {
       storageKey: storageKey
     });
   }
@@ -221,91 +276,7 @@ function generateLinkedField(schema, node) {
   return [field].concat(handles);
 }
 
-function generateConnectionField(schema, node) {
-  return generateLinkedField(schema, {
-    name: node.name,
-    alias: node.alias,
-    loc: node.loc,
-    directives: node.directives,
-    metadata: node.metadata,
-    selections: node.selections,
-    type: node.type,
-    handles: null,
-    connection: false,
-    // this is only on the linked fields with @conneciton
-    args: node.args.filter(function (arg) {
-      return !ConnectionInterface.isConnectionCall({
-        name: arg.name,
-        value: null
-      });
-    }),
-    kind: 'LinkedField'
-  });
-}
-
-function generateConnection(schema, node) {
-  var _ConnectionInterface$ = ConnectionInterface.get(),
-      EDGES = _ConnectionInterface$.EDGES,
-      PAGE_INFO = _ConnectionInterface$.PAGE_INFO;
-
-  var selections = generateSelections(schema, node.selections);
-  var edges;
-  var pageInfo;
-  selections.forEach(function (selection) {
-    if (selection.kind === 'LinkedField') {
-      if (selection.name === EDGES) {
-        edges = selection;
-      } else if (selection.name === PAGE_INFO) {
-        pageInfo = selection;
-      }
-    } else if (selection.kind === 'Stream') {
-      selection.selections.forEach(function (subselection) {
-        if (subselection.kind === 'LinkedField' && subselection.name === EDGES) {
-          edges = subselection;
-        }
-      });
-    } else if (selection.kind === 'Defer') {
-      selection.selections.forEach(function (subselection) {
-        if (subselection.kind === 'LinkedField' && subselection.name === PAGE_INFO) {
-          pageInfo = subselection;
-        }
-      });
-    }
-  });
-
-  if (edges == null || pageInfo == null) {
-    throw createUserError("Invalid connection, expected the '".concat(EDGES, "' and '").concat(PAGE_INFO, "' fields ") + 'to exist.', [node.loc]);
-  }
-
-  var stream = null;
-
-  if (node.stream != null) {
-    var _generateArgumentValu;
-
-    var trueLiteral = {
-      kind: 'Literal',
-      name: 'if',
-      value: true
-    };
-    stream = {
-      "if": node.stream["if"] != null ? (_generateArgumentValu = generateArgumentValue('if', node.stream["if"])) !== null && _generateArgumentValu !== void 0 ? _generateArgumentValu : trueLiteral : trueLiteral,
-      deferLabel: node.stream.deferLabel,
-      streamLabel: node.stream.streamLabel
-    };
-  }
-
-  return {
-    kind: 'Connection',
-    label: node.label,
-    name: node.name,
-    args: generateArgs(node.args),
-    edges: edges,
-    pageInfo: pageInfo,
-    stream: stream
-  };
-}
-
-function generateModuleImport(node, key) {
+function generateModuleImport(node) {
   var fragmentName = node.name;
   var regExpMatch = fragmentName.match(/^([a-zA-Z][a-zA-Z0-9]*)(?:_([a-zA-Z][_a-zA-Z0-9]*))?$/);
 
@@ -320,10 +291,17 @@ function generateModuleImport(node, key) {
   }
 
   return {
-    kind: 'ModuleImport',
-    documentName: node.documentName,
+    documentName: node.key,
     fragmentName: fragmentName,
-    fragmentPropName: fragmentPropName
+    fragmentPropName: fragmentPropName,
+    kind: 'ModuleImport'
+  };
+}
+
+function generateTypeDiscriminator(abstractKey) {
+  return {
+    kind: 'TypeDiscriminator',
+    abstractKey: abstractKey
   };
 }
 
@@ -344,27 +322,27 @@ function generateScalarField(node) {
     }
 
     return {
-      kind: 'ScalarHandle',
       alias: node.alias === node.name ? null : node.alias,
-      name: node.name,
       args: generateArgs(node.args),
+      filters: handle.filters,
       handle: handle.name,
       key: handle.key,
-      filters: handle.filters
+      kind: 'ScalarHandle',
+      name: node.name
     };
   }) || [];
   var field = {
-    kind: 'ScalarField',
     alias: node.alias === node.name ? null : node.alias,
-    name: node.name,
     args: generateArgs(node.args),
+    kind: 'ScalarField',
+    name: node.name,
     storageKey: null
   }; // Precompute storageKey if possible
 
   var storageKey = getStaticStorageKey(field, node.metadata);
 
   if (storageKey != null) {
-    field = (0, _objectSpread2["default"])({}, field, {
+    field = _objectSpread({}, field, {
       storageKey: storageKey
     });
   }
@@ -374,17 +352,18 @@ function generateScalarField(node) {
 
 function generateStream(schema, node) {
   if (!(node["if"] == null || node["if"].kind === 'Variable' || node["if"].kind === 'Literal' && node["if"].value === true)) {
-    var _ref2, _node$if2;
+    var _node$if$loc2, _node$if2;
 
-    throw createCompilerError('NormalizationCodeGenerator: Expected @stream `if` condition to be ' + 'a variable, unspecified, or the literal `true`.', [(_ref2 = (_node$if2 = node["if"]) === null || _node$if2 === void 0 ? void 0 : _node$if2.loc) !== null && _ref2 !== void 0 ? _ref2 : node.loc]);
+    throw createCompilerError('NormalizationCodeGenerator: Expected @stream `if` condition to be ' + 'a variable, unspecified, or the literal `true`.', [(_node$if$loc2 = (_node$if2 = node["if"]) === null || _node$if2 === void 0 ? void 0 : _node$if2.loc) !== null && _node$if$loc2 !== void 0 ? _node$if$loc2 : node.loc]);
   }
 
   return {
     "if": node["if"] != null && node["if"].kind === 'Variable' ? node["if"].variableName : null,
     kind: 'Stream',
     label: node.label,
-    metadata: node.metadata,
-    selections: generateSelections(schema, node.selections)
+    metadata: sortObjectByKey(node.metadata),
+    selections: generateSelections(schema, node.selections),
+    useCustomizedBatch: node.useCustomizedBatch != null && node.useCustomizedBatch.kind === 'Variable' ? node.useCustomizedBatch.variableName : null
   };
 }
 
@@ -413,10 +392,8 @@ function generateArgumentValue(name, value) {
           return [field.name, field.value];
         }));
         return {
-          kind: 'ObjectValue',
-          name: name,
           fields: objectKeys.map(function (fieldName) {
-            var _generateArgumentValu2;
+            var _generateArgumentValu;
 
             var fieldValue = objectValues.get(fieldName);
 
@@ -424,23 +401,25 @@ function generateArgumentValue(name, value) {
               throw createCompilerError('Expected to have object field value');
             }
 
-            return (_generateArgumentValu2 = generateArgumentValue(fieldName, fieldValue)) !== null && _generateArgumentValu2 !== void 0 ? _generateArgumentValu2 : {
+            return (_generateArgumentValu = generateArgumentValue(fieldName, fieldValue)) !== null && _generateArgumentValu !== void 0 ? _generateArgumentValu : {
               kind: 'Literal',
               name: fieldName,
               value: null
             };
-          })
+          }),
+          kind: 'ObjectValue',
+          name: name
         };
       }
 
     case 'ListValue':
       {
         return {
-          kind: 'ListValue',
-          name: name,
           items: value.items.map(function (item, index) {
             return generateArgumentValue("".concat(name, ".").concat(index), item);
-          })
+          }),
+          kind: 'ListValue',
+          name: name
         };
       }
 
@@ -478,9 +457,7 @@ function getStaticStorageKey(field, metadata) {
     return metadataStorageKey;
   }
 
-  if (!field.args || field.args.length === 0 || field.args.some(function (arg) {
-    return arg.kind !== 'Literal';
-  })) {
+  if (!field.args || field.args.length === 0 || field.args.some(argumentContainsVariables)) {
     return null;
   }