@ardatan/relay-compiler 12.0.0

package/lib/transforms/FilterDirectivesTransform.js

@@ -0,0 +1,41 @@
+/**
+ * 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.
+ *
+ * 
+ * @format
+ */
+// flowlint ambiguous-object-type:error
+'use strict';
+
+var IRTransformer = require('../core/IRTransformer');
+
+/**
+ * A transform that removes any directives that were not present in the
+ * server schema.
+ */
+function filterDirectivesTransform(context) {
+  var schemaDirectives = new Set(context.getSchema().getDirectives().filter(function (directive) {
+    return !directive.isClient;
+  }).map(function (schemaDirective) {
+    return schemaDirective.name;
+  }));
+
+  var visitDirective = function visitDirective(directive) {
+    if (schemaDirectives.has(directive.name)) {
+      return directive;
+    }
+
+    return null;
+  };
+
+  return IRTransformer.transform(context, {
+    Directive: visitDirective
+  });
+}
+
+module.exports = {
+  transform: filterDirectivesTransform
+};

package/lib/transforms/FlattenTransform.js

@@ -0,0 +1,308 @@
+/**
+ * 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.
+ *
+ * @format
+ * 
+ */
+// flowlint ambiguous-object-type:error
+'use strict';
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+
+var IRTransformer = require('../core/IRTransformer');
+
+var areEqualArgValues = require('../util/areEqualArgValues');
+
+var getIdentifierForSelection = require('../core/getIdentifierForSelection');
+
+var _require = require('../core/CompilerError'),
+    createCompilerError = _require.createCompilerError,
+    createUserError = _require.createUserError;
+
+/**
+ * Transform that flattens inline fragments, fragment spreads, and conditionals.
+ *
+ * Inline fragments are inlined (replaced with their selections) when:
+ * - The fragment type matches the type of its parent, and its `isForCodegen`,
+ *   or if it's for printing, there is no directive on the inline fragment.
+ */
+function flattenTransformImpl(context, options) {
+  var state = {
+    isForCodegen: !!(options && options.isForCodegen),
+    parentType: null
+  };
+  var visitorFn = memoizedFlattenSelection(new Map());
+  return IRTransformer.transform(context, {
+    Condition: visitorFn,
+    Defer: visitorFn,
+    Fragment: visitorFn,
+    InlineDataFragmentSpread: visitorFn,
+    InlineFragment: visitorFn,
+    LinkedField: visitorFn,
+    ModuleImport: visitorFn,
+    Root: visitorFn,
+    SplitOperation: visitorFn
+  }, function () {
+    return state;
+  });
+}
+
+function memoizedFlattenSelection(cache) {
+  return function flattenSelectionsFn(node, state) {
+    // $FlowFixMe[incompatible-use]
+    var context = this.getContext();
+    var nodeCache = cache.get(node);
+
+    if (nodeCache == null) {
+      nodeCache = new Map();
+      cache.set(node, nodeCache);
+    } // Determine the current type.
+
+
+    var parentType = state.parentType;
+    var result = nodeCache.get(parentType);
+
+    if (result != null) {
+      return result;
+    }
+
+    var type = node.kind === 'LinkedField' || node.kind === 'Fragment' || node.kind === 'Root' || node.kind === 'SplitOperation' ? node.type : node.kind === 'InlineFragment' ? node.typeCondition : parentType;
+
+    if (type == null) {
+      throw createCompilerError('FlattenTransform: Expected a parent type.', [node.loc]);
+    } // Flatten the selections in this node, creating a new node with flattened
+    // selections if possible, then deeply traverse the flattened node, while
+    // keeping track of the parent type.
+
+
+    var nextSelections = new Map();
+    var hasFlattened = flattenSelectionsInto(context.getSchema(), nextSelections, node, state, type);
+    var flattenedNode = hasFlattened ? (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, node), {}, {
+      selections: Array.from(nextSelections.values())
+    }) : node;
+    state.parentType = type; // $FlowFixMe[incompatible-use]
+
+    var deeplyFlattenedNode = this.traverse(flattenedNode, state);
+    state.parentType = parentType;
+    nodeCache.set(parentType, deeplyFlattenedNode);
+    return deeplyFlattenedNode;
+  };
+}
+/**
+ * @private
+ */
+
+
+function flattenSelectionsInto(schema, flattenedSelections, node, state, type) {
+  var hasFlattened = false;
+  node.selections.forEach(function (selection) {
+    if (selection.kind === 'InlineFragment' && shouldFlattenInlineFragment(schema, selection, state, type)) {
+      hasFlattened = true;
+      flattenSelectionsInto(schema, flattenedSelections, selection, state, type);
+      return;
+    }
+
+    var nodeIdentifier = getIdentifierForSelection(schema, selection);
+    var flattenedSelection = flattenedSelections.get(nodeIdentifier); // If this selection hasn't been seen before, keep track of it.
+
+    if (!flattenedSelection) {
+      flattenedSelections.set(nodeIdentifier, selection);
+      return;
+    } // Otherwise a similar selection exists which should be merged.
+
+
+    hasFlattened = true;
+
+    if (flattenedSelection.kind === 'InlineFragment') {
+      if (selection.kind !== 'InlineFragment') {
+        throw createCompilerError("FlattenTransform: Expected an InlineFragment, got a '".concat(selection.kind, "'"), [selection.loc]);
+      }
+
+      flattenedSelections.set(nodeIdentifier, (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, flattenedSelection), {}, {
+        selections: mergeSelections(schema, flattenedSelection, selection, state, selection.typeCondition)
+      }));
+    } else if (flattenedSelection.kind === 'Condition') {
+      if (selection.kind !== 'Condition') {
+        throw createCompilerError("FlattenTransform: Expected a Condition, got a '".concat(selection.kind, "'"), [selection.loc]);
+      }
+
+      flattenedSelections.set(nodeIdentifier, (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, flattenedSelection), {}, {
+        selections: mergeSelections(schema, flattenedSelection, selection, state, type)
+      }));
+    } else if (flattenedSelection.kind === 'ClientExtension') {
+      if (selection.kind !== 'ClientExtension') {
+        throw createCompilerError("FlattenTransform: Expected a ClientExtension, got a '".concat(selection.kind, "'"), [selection.loc]);
+      }
+
+      flattenedSelections.set(nodeIdentifier, (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, flattenedSelection), {}, {
+        selections: mergeSelections(schema, flattenedSelection, selection, state, type)
+      }));
+    } else if (flattenedSelection.kind === 'FragmentSpread') {// Ignore duplicate fragment spreads.
+    } else if (flattenedSelection.kind === 'ModuleImport') {
+      if (selection.kind !== 'ModuleImport') {
+        throw createCompilerError("FlattenTransform: Expected a ModuleImport, got a '".concat(selection.kind, "'"), [selection.loc]);
+      }
+
+      if (selection.name !== flattenedSelection.name || selection.module !== flattenedSelection.module || selection.key !== flattenedSelection.key) {
+        throw createUserError('Found conflicting @module selections: use a unique alias on the ' + 'parent fields.', [selection.loc, flattenedSelection.loc]);
+      }
+
+      flattenedSelections.set(nodeIdentifier, (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, flattenedSelection), {}, {
+        selections: mergeSelections(schema, flattenedSelection, selection, state, type)
+      }));
+    } else if (flattenedSelection.kind === 'Defer') {
+      if (selection.kind !== 'Defer') {
+        throw createCompilerError("FlattenTransform: Expected a Defer, got a '".concat(selection.kind, "'"), [selection.loc]);
+      }
+
+      flattenedSelections.set(nodeIdentifier, (0, _objectSpread2["default"])((0, _objectSpread2["default"])({
+        kind: 'Defer'
+      }, flattenedSelection), {}, {
+        selections: mergeSelections(schema, flattenedSelection, selection, state, type)
+      }));
+    } else if (flattenedSelection.kind === 'Stream') {
+      if (selection.kind !== 'Stream') {
+        throw createCompilerError("FlattenTransform: Expected a Stream, got a '".concat(selection.kind, "'"), [selection.loc]);
+      }
+
+      flattenedSelections.set(nodeIdentifier, (0, _objectSpread2["default"])((0, _objectSpread2["default"])({
+        kind: 'Stream'
+      }, flattenedSelection), {}, {
+        selections: mergeSelections(schema, flattenedSelection, selection, state, type)
+      }));
+    } else if (flattenedSelection.kind === 'LinkedField') {
+      if (selection.kind !== 'LinkedField') {
+        throw createCompilerError("FlattenTransform: Expected a LinkedField, got a '".concat(selection.kind, "'"), [selection.loc]);
+      }
+
+      assertUniqueArgsForAlias(selection, flattenedSelection); // NOTE: not using object spread here as this code is pretty hot
+
+      flattenedSelections.set(nodeIdentifier, {
+        kind: 'LinkedField',
+        alias: flattenedSelection.alias,
+        args: flattenedSelection.args,
+        connection: flattenedSelection.connection || selection.connection,
+        directives: flattenedSelection.directives,
+        handles: mergeHandles(flattenedSelection, selection),
+        loc: flattenedSelection.loc,
+        metadata: flattenedSelection.metadata,
+        name: flattenedSelection.name,
+        selections: mergeSelections(schema, flattenedSelection, selection, state, selection.type),
+        type: flattenedSelection.type
+      });
+    } else if (flattenedSelection.kind === 'ScalarField') {
+      if (selection.kind !== 'ScalarField') {
+        throw createCompilerError("FlattenTransform: Expected a ScalarField, got a '".concat(selection.kind, "'"), [selection.loc]);
+      }
+
+      assertUniqueArgsForAlias(selection, flattenedSelection);
+
+      if (selection.handles && selection.handles.length > 0) {
+        flattenedSelections.set(nodeIdentifier, (0, _objectSpread2["default"])((0, _objectSpread2["default"])({
+          kind: 'ScalarField'
+        }, flattenedSelection), {}, {
+          handles: mergeHandles(selection, flattenedSelection)
+        }));
+      }
+    } else if (flattenedSelection.kind === 'InlineDataFragmentSpread') {
+      throw createCompilerError('FlattenTransform: did not expect an InlineDataFragmentSpread node. ' + 'Only expecting InlineDataFragmentSpread in reader ASTs and this ' + 'transform to run only on normalization ASTs.', [selection.loc]);
+    } else {
+      flattenedSelection.kind;
+      throw createCompilerError("FlattenTransform: Unknown kind '".concat(flattenedSelection.kind, "'"));
+    }
+  });
+  return hasFlattened;
+}
+/**
+ * @private
+ */
+
+
+function mergeSelections(schema, nodeA, nodeB, state, type) {
+  var flattenedSelections = new Map();
+  flattenSelectionsInto(schema, flattenedSelections, nodeA, state, type);
+  flattenSelectionsInto(schema, flattenedSelections, nodeB, state, type);
+  return Array.from(flattenedSelections.values());
+}
+/**
+ * @private
+ * TODO(T19327202) This is redundant with OverlappingFieldsCanBeMergedRule once
+ * it can be enabled.
+ */
+
+
+function assertUniqueArgsForAlias(field, otherField) {
+  if (!areEqualFields(field, otherField)) {
+    throw createUserError('Expected all fields on the same parent with the name or alias ' + "'".concat(field.alias, "' to have the same name and arguments."), [field.loc, otherField.loc]);
+  }
+}
+/**
+ * @private
+ */
+
+
+function shouldFlattenInlineFragment(schema, fragment, state, type) {
+  return schema.areEqualTypes(fragment.typeCondition, schema.getRawType(type)) && (state.isForCodegen || fragment.directives.length === 0);
+}
+/**
+ * @private
+ *
+ * Verify that two fields are equal in all properties other than their
+ * selections.
+ */
+
+
+function areEqualFields(thisField, thatField) {
+  return thisField.kind === thatField.kind && thisField.name === thatField.name && thisField.alias === thatField.alias && areEqualArgs(thisField.args, thatField.args);
+}
+/**
+ * Verify that two sets of arguments are equivalent - same argument names
+ * and values. Notably this ignores the types of arguments and values, which
+ * may not always be inferred identically.
+ */
+
+
+function areEqualArgs(thisArgs, thatArgs) {
+  return thisArgs.length === thatArgs.length && thisArgs.every(function (thisArg, index) {
+    var thatArg = thatArgs[index];
+    return thisArg.name === thatArg.name && thisArg.value.kind === thatArg.value.kind && thisArg.value.variableName === thatArg.value.variableName && areEqualArgValues(thisArg.value.value, thatArg.value.value);
+  });
+}
+/**
+ * @private
+ */
+
+
+function mergeHandles(nodeA, nodeB) {
+  if (!nodeA.handles) {
+    return nodeB.handles;
+  }
+
+  if (!nodeB.handles) {
+    return nodeA.handles;
+  }
+
+  var uniqueItems = new Map();
+  nodeA.handles // $FlowFixMe[incompatible-use]
+  .concat(nodeB.handles) // $FlowFixMe[incompatible-use]
+  .forEach(function (item) {
+    return uniqueItems.set(item.name + item.key, item);
+  }); // $FlowFixMe[incompatible-return]
+
+  return Array.from(uniqueItems.values());
+}
+
+function transformWithOptions(options) {
+  return function flattenTransform(context) {
+    return flattenTransformImpl(context, options);
+  };
+}
+
+module.exports = {
+  transformWithOptions: transformWithOptions
+};

package/lib/transforms/GenerateIDFieldTransform.js

@@ -0,0 +1,137 @@
+/**
+ * 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.
+ *
+ * 
+ * @format
+ */
+// flowlint ambiguous-object-type:error
+'use strict';
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var IRTransformer = require('../core/IRTransformer');
+
+var _require = require('../core/SchemaUtils'),
+    generateIDField = _require.generateIDField;
+
+var _require2 = require('./TransformUtils'),
+    hasUnaliasedSelection = _require2.hasUnaliasedSelection;
+
+var ID = 'id';
+var NODE_TYPE = 'Node';
+
+/**
+ * A transform that adds an `id` field on any type that has an id field but
+ * where there is no unaliased `id` selection.
+ */
+function generateIDFieldTransform(context) {
+  var schema = context.getSchema();
+  var typeToIDField = new Map();
+
+  function idFieldForType(type) {
+    var idField = typeToIDField.get(type);
+
+    if (idField == null) {
+      idField = generateIDField(schema, type);
+      typeToIDField.set(type, idField);
+    }
+
+    return idField;
+  }
+
+  var typeToIDFragment = new Map();
+
+  function idFragmentForType(type) {
+    var fragment = typeToIDFragment.get(type);
+
+    if (fragment == null) {
+      fragment = {
+        kind: 'InlineFragment',
+        directives: [],
+        loc: {
+          kind: 'Generated'
+        },
+        metadata: null,
+        selections: [idFieldForType(type)],
+        typeCondition: type
+      };
+      typeToIDFragment.set(type, fragment);
+    }
+
+    return fragment;
+  }
+
+  var state = {
+    idFieldForType: idFieldForType,
+    idFragmentForType: idFragmentForType
+  };
+  return IRTransformer.transform(context, {
+    LinkedField: visitLinkedField
+  }, function () {
+    return state;
+  });
+}
+
+function visitLinkedField(field, state) {
+  // $FlowFixMe[incompatible-use]
+  var transformedNode = this.traverse(field, state); // If the field already has an unaliased `id` field, do nothing
+
+  if (hasUnaliasedSelection(field, ID)) {
+    return transformedNode;
+  } // $FlowFixMe[incompatible-use]
+
+
+  var context = this.getContext();
+  var schema = context.getSchema();
+  var unmodifiedType = schema.assertCompositeType(schema.getRawType(field.type)); // If the field type has an `id` subfield add an `id` selection
+
+  if (schema.canHaveSelections(unmodifiedType) && schema.hasId(unmodifiedType)) {
+    return (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, transformedNode), {}, {
+      selections: [].concat((0, _toConsumableArray2["default"])(transformedNode.selections), [state.idFieldForType(unmodifiedType)])
+    });
+  } // If the field type is abstract, then generate a `... on Node { id }`
+  // fragment if *any* concrete type implements Node. Then generate a
+  // `... on PossibleType { id }` for every concrete type that does *not*
+  // implement `Node`
+
+
+  var nodeType = schema.getTypeFromString(NODE_TYPE);
+
+  if (!nodeType) {
+    return transformedNode;
+  }
+
+  var nodeInterface = schema.assertInterfaceType(nodeType);
+
+  if (schema.isAbstractType(unmodifiedType)) {
+    var selections = (0, _toConsumableArray2["default"])(transformedNode.selections);
+
+    if (schema.mayImplement(unmodifiedType, nodeInterface)) {
+      selections.push(state.idFragmentForType(nodeInterface));
+    }
+
+    Array.from(schema.getPossibleTypes(schema.assertAbstractType(unmodifiedType)).values()).filter(function (concreteType) {
+      return !schema.implementsInterface(schema.assertCompositeType(concreteType), nodeInterface) && schema.hasId(concreteType);
+    }).sort(function (a, b) {
+      return schema.getTypeString(a) < schema.getTypeString(b) ? -1 : 1;
+    }).forEach(function (concreteType) {
+      selections.push(state.idFragmentForType(concreteType));
+    });
+    return (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, transformedNode), {}, {
+      selections: selections
+    });
+  }
+
+  return transformedNode;
+}
+
+module.exports = {
+  transform: generateIDFieldTransform
+};

package/lib/transforms/GenerateTypeNameTransform.js

@@ -0,0 +1,155 @@
+/**
+ * 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.
+ *
+ * 
+ * @format
+ */
+// flowlint ambiguous-object-type:error
+'use strict';
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var IRTransformer = require('../core/IRTransformer');
+
+var generateAbstractTypeRefinementKey = require('../util/generateAbstractTypeRefinementKey');
+
+var _require = require('./TransformUtils'),
+    hasUnaliasedSelection = _require.hasUnaliasedSelection;
+
+var TYPENAME_KEY = '__typename';
+var cache = new Map();
+/**
+ * A transform that adds `__typename` field on any `LinkedField` of a union or
+ * interface type where there is no unaliased `__typename` selection.
+ */
+
+function generateTypeNameTransform(context) {
+  cache = new Map();
+  var schema = context.getSchema();
+  var typenameField = {
+    kind: 'ScalarField',
+    alias: TYPENAME_KEY,
+    args: [],
+    directives: [],
+    handles: null,
+    loc: {
+      kind: 'Generated'
+    },
+    metadata: null,
+    name: TYPENAME_KEY,
+    type: schema.assertScalarFieldType(schema.getNonNullType(schema.expectStringType()))
+  };
+  return IRTransformer.transform(context, {
+    Fragment: visitFragment,
+    LinkedField: visitLinkedField,
+    InlineFragment: visitInlineFragment
+  }, function (node) {
+    return {
+      typenameField: typenameField
+    };
+  });
+}
+
+function visitFragment(fragment, state) {
+  // $FlowFixMe[incompatible-use]
+  var schema = this.getContext().getSchema();
+  var rawType = schema.getRawType(fragment.type); // $FlowFixMe[incompatible-use]
+
+  var transformedNode = this.traverse(fragment, state);
+  var isClientType = !schema.isServerType(rawType);
+
+  if (!isClientType && schema.isAbstractType(rawType)) {
+    var abstractKey = generateAbstractTypeRefinementKey(schema, rawType);
+    transformedNode = (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, transformedNode), {}, {
+      selections: [{
+        kind: 'ScalarField',
+        alias: abstractKey,
+        args: [],
+        directives: [],
+        handles: null,
+        loc: {
+          kind: 'Generated'
+        },
+        metadata: {
+          abstractKey: abstractKey
+        },
+        name: TYPENAME_KEY,
+        type: schema.assertScalarFieldType(schema.getNonNullType(schema.expectStringType()))
+      }].concat((0, _toConsumableArray2["default"])(transformedNode.selections))
+    });
+  }
+
+  return transformedNode;
+}
+
+function visitInlineFragment(fragment, state) {
+  // $FlowFixMe[incompatible-use]
+  var schema = this.getContext().getSchema();
+  var transformedNode = cache.get(fragment);
+
+  if (transformedNode != null && transformedNode.kind === 'InlineFragment') {
+    return transformedNode;
+  }
+
+  var rawType = schema.getRawType(fragment.typeCondition); // $FlowFixMe[incompatible-use]
+
+  transformedNode = this.traverse(fragment, state);
+  var isClientType = !schema.isServerType(rawType);
+
+  if (!isClientType && schema.isAbstractType(rawType)) {
+    var abstractKey = generateAbstractTypeRefinementKey(schema, rawType);
+    transformedNode = (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, transformedNode), {}, {
+      selections: [{
+        kind: 'ScalarField',
+        alias: abstractKey,
+        args: [],
+        directives: [],
+        handles: null,
+        loc: {
+          kind: 'Generated'
+        },
+        metadata: {
+          abstractKey: abstractKey
+        },
+        name: TYPENAME_KEY,
+        type: schema.assertScalarFieldType(schema.getNonNullType(schema.expectStringType()))
+      }].concat((0, _toConsumableArray2["default"])(transformedNode.selections))
+    });
+  }
+
+  cache.set(fragment, transformedNode);
+  return transformedNode;
+}
+
+function visitLinkedField(field, state) {
+  // $FlowFixMe[incompatible-use]
+  var schema = this.getContext().getSchema();
+  var transformedNode = cache.get(field);
+
+  if (transformedNode != null && transformedNode.kind === 'LinkedField') {
+    return transformedNode;
+  } // $FlowFixMe[incompatible-use]
+
+
+  transformedNode = this.traverse(field, state);
+
+  if (schema.isAbstractType(schema.getRawType(transformedNode.type)) && !hasUnaliasedSelection(transformedNode, TYPENAME_KEY)) {
+    transformedNode = (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, transformedNode), {}, {
+      selections: [state.typenameField].concat((0, _toConsumableArray2["default"])(transformedNode.selections))
+    });
+  }
+
+  cache.set(field, transformedNode);
+  return transformedNode;
+}
+
+module.exports = {
+  transform: generateTypeNameTransform
+};