@apollo/federation-internals 2.4.4 → 2.4.6

package/src/operations.ts

@@ -46,6 +46,7 @@ import {
   isLeafType,
   Variables,
   isObjectType,
+  NamedType,
 } from "./definitions";
 import { isInterfaceObjectType } from "./federation";
 import { ERRORS } from "./error";
@@ -152,7 +153,11 @@ export class Field<TArgs extends {[key: string]: any} = {[key: string]: any}> ex
   }
 
   isLeafField(): boolean {
-    return isLeafType(baseType(this.definition.type!));
+    return isLeafType(this.baseType());
+  }
+
+  baseType(): NamedType {
+    return baseType(this.definition.type!);
   }
 
   withUpdatedDefinition(newDefinition: FieldDefinition<any>): Field<TArgs> {
@@ -674,7 +679,7 @@ export function concatOperationPaths(head: OperationPath, tail: OperationPath):
 
 function isUselessFollowupElement(first: OperationElement, followup: OperationElement, conditionals: Directive<any, any>[]): boolean {
   const typeOfFirst = first.kind === 'Field'
-    ? baseType(first.definition.type!)
+    ? first.baseType()
     : first.typeCondition;
 
   // The followup is useless if it's a fragment (with no directives we would want to preserve) whose type
@@ -1042,7 +1047,6 @@ export class NamedFragments {
       dependsOn: string[],
     };
     const fragmentsMap = new Map<string, FragmentInfo>();
-
     const removedFragments = new Set<string>();
     for (const fragment of this.definitions()) {
       const mappedSelectionSet = mapper(fragment.selectionSet.expandAllFragments().trimUnsatisfiableBranches(fragment.typeCondition));
@@ -1430,7 +1434,73 @@ export class SelectionSet {
     for (const selection of selections) {
       mergedSubselections.add(selection.selectionSet!);
     }
-    return first.withUpdatedSelectionSet(mergedSubselections.toSelectionSet(first.selectionSet.parentType));
+
+    // We know all the `selections` are basically for the same element (same field or same inline fragment),
+    // and we want to return a single selection with the merged selections. There is a subtlety regarding
+    // the parent type of that merged selection however: we cannot safely rely on the parent type of any
+    // of the individual selections, because this can be incorrect. Let's illustrate.
+    // Consider that we have:
+    // ```graphql
+    //   type Query {
+    //     a: A!
+    //   }
+    //
+    //   interface IA1 {
+    //     b: IB1!
+    //   }
+    //
+    //   interface IA2 {
+    //     b: IB2!
+    //   }
+    //
+    //   type A implements IA1 & IA2 {
+    //     b: B!
+    //   }
+    //
+    //   interface IB1 {
+    //     v1: Int!
+    //   }
+    //
+    //   interface IB2 {
+    //     v2: Int!
+    //   }
+    //
+    //   type B implements IB1 & IB2 {
+    //     v1: Int!
+    //     v2: Int!
+    //   }
+    // ```
+    // and suppose that we're trying to check if selection set:
+    //  maybeSuperset = { ... on IA1 { b { v1 } } ... on IA2 { b { v2 } } }  // (parent type A)
+    // contains selection set:
+    //  maybeSubset   = { b { v1 v2 } }                                      // (parent type A)
+    //
+    // In that case, the `contains` method below will call this function with the 2 sub-selections
+    // from `maybeSuperset`, but with the unecessary interface fragment removed (reminder that the
+    // parent type is `A`, so the "casts" into the interfaces are semantically useless).
+    //
+    // And so in that case, the argument to this method will be:
+    //   [ b { v1 } (parent type IA1), b { v2 } (parent type IA2) ]
+    // but then, the sub-selection `{ v1 }` of the 1st value will have parent type IB1,
+    //       and the sub-selection `{ v2 }` of the 2nd value will have parent type IB2,
+    // neither of which work for the merge sub-selection.
+    //
+    // Instead, we want to use as parent type the type of field `b` the parent type of `this`
+    // (which is `maybeSupeset` in our example). Which means that we want to use type `B` for
+    // the sub-selection, which is now guaranteed to work (or `maybeSupergerset` wouldn't have
+    // been valid).
+    //
+    // Long story short, we get that type by rebasing any of the selection element (we use the
+    // first as we have it) on `this.parentType`, which gives use the element we want, and we
+    // use the type of that for the sub-selection.
+
+    if (first.kind === 'FieldSelection') {
+      const rebasedField = first.element.rebaseOn(this.parentType);
+      return new FieldSelection(rebasedField, mergedSubselections.toSelectionSet(rebasedField.baseType() as CompositeType));
+    } else {
+      const rebasedFragment = first.element.rebaseOn(this.parentType);
+      return new InlineFragmentSelection(rebasedFragment, mergedSubselections.toSelectionSet(rebasedFragment.castedType()));
+    }
   }
 
   contains(that: SelectionSet): boolean {
@@ -1456,6 +1526,28 @@ export class SelectionSet {
   // validate this (`canApplyAtType` is not free, and we want to avoid repeating it multiple times).
   diffWithNamedFragmentIfContained(candidate: NamedFragmentDefinition, parentType: CompositeType): { contains: boolean, diff?: SelectionSet } {
     const that = candidate.selectionSetAtType(parentType);
+    // It's possible that while the fragment technically applies at `parentType`, it's "rebasing" on
+    // `parentType` is empty, or contains only `__typename`. For instance, suppose we have
+    // a union `U = A | B | C`, and then a fragment:
+    // ```graphql
+    //   fragment F on U {
+    //     ... on A {
+    //       x
+    //     }
+    //     ... on b {
+    //       y
+    //     }
+    //   }
+    // ```
+    // It is then possible to apply `F` when the parent type is `C`, but this ends up selecting
+    // nothing at all.
+    //
+    // Returning `contains: true` in those cases is, while not 100% incorrect, at least not productive,
+    // and so we skip right away in that case. This is essentially an optimisation.
+    if (that.isEmpty() || (that.selections().length === 1 && that.selections()[0].isTypenameField())) {
+      return { contains: false };
+    }
+
     if (this.contains(that)) {
       // One subtlety here is that at "this" sub-selections may already have been optimized with some fragments. It's
       // usually ok because `candidate` will also use those fragments, but one fragments that `candidate` can never be
@@ -1483,6 +1575,17 @@ export class SelectionSet {
       const otherSelections = that.triviallyNestedSelectionsForKey(this.parentType, key);
       const allSelections = thatSelection ? [thatSelection].concat(otherSelections) : otherSelections;
       if (allSelections.length === 0) {
+        // If it is a fragment spread, and we didn't find it in `that`, then we try to expand that
+        // fragment and see if that result is entirely covered by `that`. If that is the case, then it means
+        // `thisSelection` does not need to be in the returned "diff". If it's not entirely covered,
+        // we just add the spread itself to the diff: even if some parts of it were covered by `that`,
+        // keeping just the fragment is, in a sense, more condensed.
+        if (thisSelection instanceof FragmentSpreadSelection) {
+          const expanded = thisSelection.selectionSet.expandAllFragments().trimUnsatisfiableBranches(this.parentType);
+          if (expanded.minus(that).isEmpty()) {
+            continue;
+          }
+        }
         updated.add(thisSelection);
       } else {
         const selectionDiff = allSelections.reduce<Selection | undefined>((prev, val) => prev?.minus(val), thisSelection);
@@ -1790,7 +1893,7 @@ function makeSelection(parentType: CompositeType, updates: SelectionUpdate[], fr
   }
 
   const element = updateElement(first).rebaseOn(parentType);
-  const subSelectionParentType = element.kind === 'Field' ? baseType(element.definition.type!) : element.castedType();
+  const subSelectionParentType = element.kind === 'Field' ? element.baseType() : element.castedType();
   if (!isCompositeType(subSelectionParentType)) {
     // This is a leaf, so all updates should correspond ot the same field and we just use the first.
     return selectionOfElement(element);
@@ -1984,6 +2087,11 @@ abstract class AbstractSelection<TElement extends OperationElement, TIsLeaf exte
     return this.element.parentType;
   }
 
+  isTypenameField(): boolean {
+    // Overridden where appropriate
+    return false;
+  }
+
   collectVariables(collector: VariableCollector) {
     this.element.collectVariables(collector);
     this.selectionSet?.collectVariables(collector)
@@ -2110,6 +2218,10 @@ export class FieldSelection extends AbstractSelection<Field<any>, undefined, Fie
     return this;
   }
 
+  isTypenameField(): boolean {
+    return this.element.definition.name === typenameFieldName;
+  }
+
   withUpdatedComponents(field: Field<any>, selectionSet: SelectionSet | undefined): FieldSelection {
     return new FieldSelection(field, selectionSet);
   }
@@ -2120,7 +2232,7 @@ export class FieldSelection extends AbstractSelection<Field<any>, undefined, Fie
 
   optimize(fragments: NamedFragments): Selection {
     let optimizedSelection = this.selectionSet ? this.selectionSet.optimizeSelections(fragments) : undefined;
-    const fieldBaseType = baseType(this.element.definition.type!);
+    const fieldBaseType = this.element.baseType();
     if (isCompositeType(fieldBaseType) && optimizedSelection) {
       const optimized = this.tryOptimizeSubselectionWithFragments({
         parentType: fieldBaseType,
@@ -2213,7 +2325,7 @@ export class FieldSelection extends AbstractSelection<Field<any>, undefined, Fie
       return this.withUpdatedElement(rebasedElement);
     }
 
-    const rebasedBase = baseType(rebasedElement.definition.type!);
+    const rebasedBase = rebasedElement.baseType();
     if (rebasedBase === this.selectionSet.parentType) {
       return this.withUpdatedElement(rebasedElement);
     }
@@ -2279,7 +2391,7 @@ export class FieldSelection extends AbstractSelection<Field<any>, undefined, Fie
       return this;
     }
 
-    const base = baseType(this.element.definition.type!)
+    const base = this.element.baseType()
     assert(isCompositeType(base), () => `Field ${this.element} should not have a sub-selection`);
     const trimmed = (options?.recursive ?? true) ? this.mapToSelectionSet((s) => s.trimUnsatisfiableBranches(base)) : this;
     // In rare caes, it's possible that everything in the sub-selection was trimmed away and so the
@@ -2385,7 +2497,6 @@ export abstract class FragmentSelection extends AbstractSelection<FragmentElemen
           || (isObjectType(parentType) && possibleRuntimeTypes(this.element.typeCondition).some((t) => t.name === parentType.name))
       );
   }
-
 }
 
 class InlineFragmentSelection extends FragmentSelection {
@@ -2597,7 +2708,7 @@ class InlineFragmentSelection extends FragmentSelection {
         if (isObjectType(thisCondition) || !possibleRuntimeTypes(thisCondition).includes(currentType)) {
           return undefined;
         } else {
-          const trimmed =this.selectionSet.trimUnsatisfiableBranches(currentType, options);
+          const trimmed = this.selectionSet.trimUnsatisfiableBranches(currentType, options);
           return trimmed.isEmpty() ? undefined : trimmed;
         }
       }
@@ -2728,8 +2839,10 @@ class FragmentSpreadSelection extends FragmentSelection {
     assert(false, `Unsupported`);
   }
 
-  trimUnsatisfiableBranches(_: CompositeType): FragmentSelection  {
-    return this;
+  trimUnsatisfiableBranches(parentType: CompositeType): FragmentSelection  {
+    // We must update the spread parent type if necessary since we're not going deeper,
+    // or we'll be fundamentally losing context.
+    return this.rebaseOn(parentType);
   }
 
   namedFragments(): NamedFragments | undefined {
@@ -2766,18 +2879,30 @@ class FragmentSpreadSelection extends FragmentSelection {
     return this;
   }
 
-  rebaseOn(_parentType: CompositeType): FragmentSelection {
-    // This is a little bit iffy, because the fragment could link to a schema (typically the supergraph API one)
-    // that is different from the one of `_selectionSet` (say, a subgraph fetch selection in which we're trying to
-    // reuse a user fragment). But in practice, we expand all fragments when we do query planning and only re-add
-    // fragments back at the very end, so this should be fine. Importantly, we don't want this method to mistakenly
-    // expand the spread, as that would compromise the code that optimize subgraph fetches to re-use named
+  rebaseOn(parentType: CompositeType): FragmentSelection {
+    // We preserve the parent type here, to make sure we don't lose context, but we actually don't
+    // want to expand the spread  as that would compromise the code that optimize subgraph fetches to re-use named
     // fragments.
-    return this;
+    //
+    // This is a little bit iffy, because the fragment may not apply at this parent type, but we
+    // currently leave it to the caller to ensure this is not a mistake. But most of the
+    // QP code works on selections with fully expanded fragments, so this code (and that of `canAddTo`
+    // on come into play in the code for reusing fragments, and that code calls those methods
+    // appropriately.
+    if (this.parentType === parentType) {
+      return this;
+    }
+    return new FragmentSpreadSelection(
+      parentType,
+      this.fragments,
+      this.namedFragment,
+      this.spreadDirectives,
+    );
   }
 
   canAddTo(_: CompositeType): boolean {
-    // Mimicking the logic of `rebaseOn`.
+    // Since `rebaseOn` never fail, we copy the logic here and always return `true`. But as
+    // mentioned in `rebaseOn`, this leave it a bit to the caller to know what he is doing.
     return true;
   }
 

package/src/utils.ts

@@ -401,7 +401,7 @@ export function printHumanReadableList(
 }
 
 export type Concrete<Type> = {
-  [Property in keyof Type]-?: Type[Property];
+  [Property in keyof Type]-?: Concrete<Type[Property]>;
 };
 
 // for use with Array.filter

package/CHANGELOG.md

@@ -1,205 +0,0 @@
-# CHANGELOG for `@apollo/federation-internals`
-
-## 2.4.4
-
-## 2.4.3
-### Patch Changes
-
-
-- Improves the heuristics used to try to reuse the query named fragments in subgraph fetches. Said fragment will be reused ([#2541](https://github.com/apollographql/federation/pull/2541))
-  more often, which can lead to smaller subgraph queries (and hence overall faster processing).
-
-## 2.4.2
-### Patch Changes
-
-
-- Allow passing print options to the `compose` method to impact how the supergraph is printed, and adds new printing ([#2042](https://github.com/apollographql/federation/pull/2042))
-  options to order all elements of the schema.
-
-- Fix potential bug when an `@interfaceObject` type has a `@requires`. When an `@interfaceObject` type has a field with a ([#2524](https://github.com/apollographql/federation/pull/2524))
-  `@requires` and the query requests that field only for some specific implementations of the corresponding interface,
-  then the generated query plan was sometimes invalid and could result in an invalid query to a subgraph (against a
-  subgraph that rely on `@apollo/subgraph`, this lead the subgraph to produce an error message looking like `"The
-  _entities resolver tried to load an entity for type X, but no object or interface type of that name was found in the
-  schema"`).
-
-## 2.4.1
-### Patch Changes
-
-
-- Fix issues (incorrectly rejected composition and/or subgraph errors) with `@interfaceObject`. Those issues may occur ([#2494](https://github.com/apollographql/federation/pull/2494))
-  either due to some use of `@requires` in an `@interfaceObject` type, or when some subgraph `S` defines a type that is an
-  implementation of an interface `I` in the supergraph, and there is an `@interfaceObject` for `I` in another subgraph,
-  but `S` does not itself defines `I`.
-
-- Fix assertion error during query planning in some cases where queries has some unsatisfiable branches (a part of the ([#2486](https://github.com/apollographql/federation/pull/2486))
-  query goes through type conditions that no runtime types satisfies).
-
-- Start building packages with TS 5.x, which should have no effect on consumers ([#2480](https://github.com/apollographql/federation/pull/2480))
-
-
-- Improves reuse of named fragments in subgraph fetches. When a question has named fragments, the code tries to reuse ([#2497](https://github.com/apollographql/federation/pull/2497))
-  those fragment in subgraph fetches is those can apply (so when the fragment is fully queried in a single subgraph fetch).
-  However, the existing was only able to reuse those fragment in a small subset of cases. This change makes it much more
-  likely that _if_ a fragment can be reused, it will be.
-
-## 2.4.0
-### Patch Changes
-
-
-- Refactor the internal implementation of selection sets used by the query planner to decrease the code complexity and ([#2387](https://github.com/apollographql/federation/pull/2387))
-  improve query plan generation performance in many cases.
-
-- Revert #2293. Removing URL import causes a problem when running under deno. ([#2451](https://github.com/apollographql/federation/pull/2451))
-
-
-- Use globally available URL object instead of node builtin "url" module ([#2293](https://github.com/apollographql/federation/pull/2293))
-
-
-- Optimises query plan generation for parts of queries that can statically be known to not cross across subgraphs ([#2449](https://github.com/apollographql/federation/pull/2449))
-
-## 2.4.0-alpha.1
-### Patch Changes
-
-
-- Revert #2293. Removing URL import causes a problem when running under deno. ([#2451](https://github.com/apollographql/federation/pull/2451))
-
-## 2.4.0-alpha.0
-### Patch Changes
-
-
-- Handle defaulted variables correctly during post-processing. ([#2443](https://github.com/apollographql/federation/pull/2443))
-  
-  Users who tried to use built-in conditional directives (skip/include) with _defaulted_ variables and no variable provided would encounter an error thrown by operation post-processing saying that the variables weren't provided. The defaulted values went unaccounted for, so the operation would validate but then fail an assertion while resolving the conditional.
-  
-  With this change, defaulted variable values are now collected and provided to post-processing (with defaults being overwritten by variables that are actually provided).
-
-
-## 2.3.5
-
-## 2.3.4
-### Patch Changes
-
-- Use globally available URL object instead of node builtin "url" module ([#2293](https://github.com/apollographql/federation/pull/2293))
-
-## 2.3.3
-
-## 2.3.2
-
-## 2.3.1
-
-## 2.3.0
-
-- Fix incorrect handling of `@external` on a type when dealing when adding `@shareable` during fed1 schema upgrades [PR #2343](https://github.com/apollographql/federation/pull/2343).
-
-## 2.2.1
-
-- Fix federation spec always being expanded to the last version [PR #2274](https://github.com/apollographql/federation/pull/2274).
-
-## 2.2.0
-
-- Preserve default values of input object fields [PR #2218](https://github.com/apollographql/federation/pull/2218).
-- Provide support for marking @external on object type [PR #2214](https://github.com/apollographql/federation/pull/2214)
-- Drop support for node12 [PR #2202](https://github.com/apollographql/federation/pull/2202)
-- Correctly reject field names starting with `__` [PR #2237](https://github.com/apollographql/federation/pull/2237).
-- Preserve default values of input object fields [PR #2218](https://github.com/apollographql/federation/pull/2218).
-
-## 2.1.4
-
-- Ensures supergraph `@defer`/`@stream` definitions of supergraph are not included in the API schema [PR #2212](https://github.com/apollographql/federation/pull/2212).
-- Fix validation of variable on input field not taking default into account [PR #2176](https://github.com/apollographql/federation/pull/2176).
-
-## 2.1.0
-
-- Update peer dependency `graphql` to `^16.5.0` to use `GraphQLErrorOptions` [PR #2060](https://github.com/apollographql/federation/pull/2060)
-- Don't require `@link` when using `@composeDirective` [PR #2046](https://github.com/apollographql/federation/pull/2046)
-- Add `@defer` support [PR #1958](https://github.com/apollographql/federation/pull/1958)
-- Add `@composeDirective` directive to specify directives that should be merged to the supergraph during composition [PR #1996](https://github.com/apollographql/federation/pull/1996).
-- Expand support for Node.js v18 [PR #1884](https://github.com/apollographql/federation/pull/1884)
-
-## 2.0.4
-
-- Fix issue when all root operations were defined in an `extend schema` [PR #1875](https://github.com/apollographql/federation/issues/1875).
-
-## 2.0.3
-
-- Fix bug with type extension of empty type definition [PR #1821](https://github.com/apollographql/federation/pull/1821)
-
-## 2.0.2
-
-- Fix bug removing an enum type [PR #1813](https://github.com/apollographql/federation/pull/1813)
-- Fix `Schema.clone` when directive application happens before definition [PR #1785](https://github.com/apollographql/federation/pull/1785)
-- More helpful error message for errors encountered while reading supergraphs generated pre-federation 2 [PR #1796](https://github.com/apollographql/federation/pull/1796)
-- Fix bug applying an imported federation directive on another directive definition [PR #1797](https://github.com/apollographql/federation/pull/1797).
-- Prevent non-core-feature elements from being marked @inaccessible if referenced by core feature elements [PR #1769](https://github.com/apollographql/federation/pull/1769)
-- Improve fed1 schema support during composition [PR #1735](https://github.com/apollographql/federation/pull/1735)
-- Honor directive imports when directive name is spec name [PR #1720](https://github.com/apollographql/federation/pull/1720)
-
-## v2.0.1
-
-- Use `for: SECURITY` in the core/link directive application in the supergraph for `@inaccessible` [PR #1715](https://github.com/apollographql/federation/pull/1715)
-
-## v2.0.0
-
-- Previous preview release promoted to general availability! Please see previous changelog entries for full info.
-
-## v2.0.0-preview.14
-
-- Implement `buildSubgraphSchema` using federation internals [PR #1697](https://github.com/apollographql/federation/pull/1697)
-
-
-## v2.0.0-preview.11
-
-- Add support for `@inaccessible` v0.2 [PR #1678](https://github.com/apollographql/federation/pull/1678)
-- Add a level to hints, uppercase their code and related fixes [PR #1683](https://github.com/apollographql/federation/pull/1683).
-
-## v2.0.0-preview.9
-
-- Adds Support for `@tag/v0.2`, which allows the `@tag` directive to be additionally placed on arguments, scalars, enums, enum values, input objects, and input object fields. [PR #1652](https://github.com/apollographql/federation/pull/1652).
-- Add missing `includeDeprecated` argument for `args` and `inputFields` when defining introspection fields [PR #1584](https://github.com/apollographql/federation/pull/1584)
-- Adds support for the `@override` directive on fields to indicate that a field should be moved from one subgraph to another. [PR #1484](https://github.com/apollographql/federation/pull/1484)
-
-## v2.0.0-preview.5
-
-- Fix propagation of `@tag` to the supergraph and allows @tag to be repeated. Additionally, merged directives (only `@tag` and `@deprecated` currently) are not allowed on external fields anymore [PR #1592](https://github.com/apollographql/federation/pull/1592).
-
-## v2.0.0-preview.4
-
-- Make error messages more actionable when constructing subgraphs from a supergraph [PR #1586](https://github.com/apollographql/federation/pull/1586)
-
-## v2.0.0-preview.3
-
-- Fix issue that created type extensions with descriptions, which is invalid graphQL syntax [PR #1582](https://github.com/apollographql/federation/pull/1582).
-
-## v2.0.0-preview.2
-
-- Re-publishing release which published to npm with stale build artifacts from `version-0.x` release.
-
-## v2.0.0-preview.1
-
-- No-op publish to account for publishing difficulties.
-
-## v2.0.0-preview.0
-
-- Initial "preview" release.
-
-## v2.0.0-alpha.6
-
-- Avoid incomplete subgraphs when extracting them from the supergraph. [PR #1511](https://github.com/apollographql/federation/pull/1511)
-
-## v2.0.0-alpha.5
-
-- Remove `graphql@15` from peer dependencies [PR #1472](https://github.com/apollographql/federation/pull/1472).
-
-## v2.0.0-alpha.3
-
-- Assign and document error codes for all errors [PR #1274](https://github.com/apollographql/federation/pull/1274).
-- Fix issue reading some 0.x generated supergraphs [PR #1351](https://github.com/apollographql/federation/pull/1351).
-
-## v2.0.0-alpha.2
-
-- __BREAKING__: Bump graphql peer dependency to `^15.7.0` [PR #1200](https://github.com/apollographql/federation/pull/1200)
-
-## v2.0.0-alpha.1
-
-- :tada: Initial alpha release of Federation 2.0.  For more information, see our [documentation](https://www.apollographql.com/docs/federation/v2/).  We look forward to your feedback!

package/jest.config.js

@@ -1,11 +0,0 @@
-const baseConfig = require('../jest.config.base');
-
-/** @typedef {import('ts-jest/dist/types')} */
-/** @type {import('@jest/types').Config.InitialOptions} */
-module.exports = {
-  ...baseConfig,
-  displayName: {
-    name: '@apollo/federation-internals',
-    color: 'magenta'
-  }
-};