relay-compiler 9.0.0 → 10.1.0

package/lib/codegen/NormalizationCodeGenerator.js

@@ -12,10 +12,22 @@
 
 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;
@@ -39,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)
   };
 }
@@ -49,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)
   };
 }
@@ -58,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));
@@ -68,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':
@@ -106,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
     };
   });
 }
@@ -127,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
   };
 }
 
@@ -164,21 +218,20 @@ 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
-    }; // T45504512: new connection model
-    // NOTE: this intentionally adds a dynamic key in order to avoid
+      kind: 'LinkedHandle',
+      name: node.name
+    }; // NOTE: this intentionally adds a dynamic key in order to avoid
     // triggering updates to existing queries that do not use dynamic
     // keys.
 
     if (handle.dynamicKey != null) {
       var dynamicKeyArgName = '__dynamicKey';
-      handleNode = (0, _objectSpread2["default"])({}, handleNode, {
+      handleNode = _objectSpread(_objectSpread({}, handleNode), {}, {
         dynamicKey: {
           kind: 'Variable',
           name: dynamicKeyArgName,
@@ -187,24 +240,34 @@ function generateLinkedField(schema, node) {
       });
     }
 
+    if (handle.handleArgs != null) {
+      var handleArgs = generateArgs(handle.handleArgs);
+
+      if (handleArgs != null) {
+        handleNode = _objectSpread(_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(_objectSpread({}, field), {}, {
       storageKey: storageKey
     });
   }
@@ -212,7 +275,7 @@ function generateLinkedField(schema, node) {
   return [field].concat(handles);
 }
 
-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]*))?$/);
 
@@ -227,15 +290,22 @@ 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
   };
 }
 
 function generateScalarField(node) {
-  var _node$metadata;
+  var _node$metadata, _node$metadata2;
 
   // flowlint-next-line sketchy-null-mixed:off
   if ((_node$metadata = node.metadata) === null || _node$metadata === void 0 ? void 0 : _node$metadata.skipNormalizationNode) {
@@ -250,49 +320,62 @@ function generateScalarField(node) {
       throw createUserError('Dynamic key values are not supported on scalar fields.', [handle.dynamicKey.loc]);
     }
 
-    return {
-      kind: 'ScalarHandle',
+    var nodeHandle = {
       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
     };
+
+    if (handle.handleArgs != null) {
+      // $FlowFixMe handleArgs exists in Handle
+      nodeHandle.handleArgs = generateArgs(handle.handleArgs);
+    }
+
+    return nodeHandle;
   }) || [];
   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(_objectSpread({}, field), {}, {
       storageKey: storageKey
     });
   }
 
+  if (((_node$metadata2 = node.metadata) === null || _node$metadata2 === void 0 ? void 0 : _node$metadata2.flight) === true) {
+    field = _objectSpread(_objectSpread({}, field), {}, {
+      kind: 'FlightField'
+    });
+  }
+
   return [field].concat(handles);
 }
 
 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',
-    useCustomizedBatch: node.useCustomizedBatch != null && node.useCustomizedBatch.kind === 'Variable' ? node.useCustomizedBatch.variableName : null,
     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
   };
 }
 
@@ -321,8 +404,6 @@ function generateArgumentValue(name, value) {
           return [field.name, field.value];
         }));
         return {
-          kind: 'ObjectValue',
-          name: name,
           fields: objectKeys.map(function (fieldName) {
             var _generateArgumentValu;
 
@@ -337,18 +418,20 @@ function generateArgumentValue(name, value) {
               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
         };
       }
 
@@ -386,9 +469,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;
   }