feat: add composition options

cli/src/commands/router/commands/compose.ts

@@ -207,7 +207,9 @@ export default (opts: BaseCommandOptions) => {
           definitions: parse(s.sdl),
         };
       }),
-      options.disableResolvabilityValidation,
+      {
+        disableResolvabilityValidation: options.disableResolvabilityValidation,
+      },
     );
 
     if (!result.success) {
@@ -587,7 +589,9 @@ async function buildFeatureFlagsConfig(
         url: normalizeURL(s.routingUrl),
         definitions: parse(s.sdl),
       })),
-      options.disableResolvabilityValidation,
+      {
+        disableResolvabilityValidation: options.disableResolvabilityValidation,
+      },
     );
 
     if (!featureResult.success) {

cli/src/utils.ts

@@ -1,6 +1,7 @@
 /* eslint-disable import/named */
 import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import {
+  CompositionOptions,
   federateSubgraphs,
   FederationResult,
   ROUTER_COMPATIBILITY_VERSION_ONE,
@@ -179,9 +180,9 @@ export const introspectSubgraph = async ({
 /**
  * Composes a list of subgraphs into a single schema.
  */
-export function composeSubgraphs(subgraphs: Subgraph[], disableResolvabilityValidation?: boolean): FederationResult {
+export function composeSubgraphs(subgraphs: Subgraph[], options?: CompositionOptions): FederationResult {
   // @TODO get router compatibility version programmatically
-  return federateSubgraphs({ disableResolvabilityValidation, subgraphs, version: ROUTER_COMPATIBILITY_VERSION_ONE });
+  return federateSubgraphs({ options, subgraphs, version: ROUTER_COMPATIBILITY_VERSION_ONE });
 }
 
 export type ConfigData = Partial<KeycloakToken & { organizationSlug: string; lastUpdateCheck: number }>;

composition/src/federation/federation.ts

@@ -13,40 +13,40 @@ import {
 import { ROUTER_COMPATIBILITY_VERSION_ONE } from '../router-compatibility-version/router-compatibility-version';
 
 export function federateSubgraphs({
-  disableResolvabilityValidation,
+  options,
   subgraphs,
   version = ROUTER_COMPATIBILITY_VERSION_ONE,
 }: FederateSubgraphsParams): FederationResult {
   switch (version) {
     default: {
-      return federateSubgraphsV1({ disableResolvabilityValidation, subgraphs });
+      return federateSubgraphsV1({ options, subgraphs });
     }
   }
 }
 
 // the flow when publishing a subgraph that also has contracts
 export function federateSubgraphsWithContracts({
-  disableResolvabilityValidation,
+  options,
   subgraphs,
   tagOptionsByContractName,
   version = ROUTER_COMPATIBILITY_VERSION_ONE,
 }: FederateSubgraphsWithContractsParams): FederationResultWithContracts {
   switch (version) {
     default: {
-      return federateSubgraphsWithContractsV1({ disableResolvabilityValidation, subgraphs, tagOptionsByContractName });
+      return federateSubgraphsWithContractsV1({ options, subgraphs, tagOptionsByContractName });
     }
   }
 }
 
 export function federateSubgraphsContract({
   contractTagOptions,
-  disableResolvabilityValidation,
+  options,
   subgraphs,
   version = ROUTER_COMPATIBILITY_VERSION_ONE,
 }: FederateSubgraphsContractParams): FederationResult {
   switch (version) {
     default: {
-      return federateSubgraphsContractV1({ disableResolvabilityValidation, subgraphs, contractTagOptions });
+      return federateSubgraphsContractV1({ contractTagOptions, options, subgraphs });
     }
   }
 }

composition/src/federation/types.ts

@@ -10,6 +10,7 @@ import { FieldConfiguration } from '../router-configuration/types';
 import { Subgraph, SubgraphConfig } from '../subgraph/types';
 import { SupportedRouterCompatibilityVersion } from '../router-compatibility-version/router-compatibility-version';
 import { ContractName, DirectiveName, SubgraphName, TypeName } from '../types/types';
+import { CompositionOptions } from '../types/params';
 
 export type FederationFailure = {
   errors: Array<Error>;
@@ -71,19 +72,20 @@ export type MutualParentDefinitionData = {
 export type FederateSubgraphsParams = {
   subgraphs: Array<Subgraph>;
   disableResolvabilityValidation?: boolean;
+  options?: CompositionOptions;
   version?: SupportedRouterCompatibilityVersion;
 };
 
 export type FederateSubgraphsWithContractsParams = {
   subgraphs: Array<Subgraph>;
   tagOptionsByContractName: Map<ContractName, ContractTagOptions>;
-  disableResolvabilityValidation?: boolean;
+  options?: CompositionOptions;
   version?: SupportedRouterCompatibilityVersion;
 };
 
 export type FederateSubgraphsContractParams = {
   contractTagOptions: ContractTagOptions;
   subgraphs: Array<Subgraph>;
-  disableResolvabilityValidation?: boolean;
+  options?: CompositionOptions;
   version?: SupportedRouterCompatibilityVersion;
 };

composition/src/index.ts

@@ -5,6 +5,7 @@ export * from './errors/types';
 export * from './federation/federation';
 export * from './federation/types';
 export * from './normalization/normalization';
+export * from './normalization/params';
 export * from './normalization/types';
 export * from './resolvability-graph/graph';
 export * from './resolvability-graph/graph-nodes';
@@ -19,6 +20,7 @@ export * from './schema-building/ast';
 export * from './schema-building/types';
 export * from './schema-building/utils';
 export * from './subgraph/types';
+export * from './types/params';
 export * from './types/types';
 export * from './utils/composition-version';
 export * from './utils/params';
@@ -34,9 +36,9 @@ export * from './v1/constants/integers';
 export * from './v1/constants/non-directive-definitions';
 export * from './v1/constants/strings';
 export * from './v1/constants/type-nodes';
+export * from './v1/federation/params';
 export * from './v1/federation/utils';
 export * from './v1/federation/walkers';
-export * from './v1/federation/types';
 export * from './v1/normalization/directive-definition-data';
 export * from './v1/normalization/utils';
 export * from './v1/normalization/types';

composition/src/normalization/normalization.ts

@@ -3,47 +3,45 @@ import {
   normalizeSubgraph as normalizeSubgraphV1,
   normalizeSubgraphFromString as normalizeSubgraphFromStringV1,
 } from '../v1/normalization/normalization-factory';
-import {
-  ROUTER_COMPATIBILITY_VERSION_ONE,
-  SupportedRouterCompatibilityVersion,
-} from '../router-compatibility-version/router-compatibility-version';
+import { ROUTER_COMPATIBILITY_VERSION_ONE } from '../router-compatibility-version/router-compatibility-version';
 import { BatchNormalizationResult, NormalizationResult } from './types';
-import { DocumentNode } from 'graphql';
-import { Graph } from '../resolvability-graph/graph';
-import { Subgraph } from '../subgraph/types';
+import { BatchNormalizeParams, NormalizeSubgraphFromStringParams, NormalizeSubgraphParams } from './params';
 
-export function normalizeSubgraphFromString(
-  schema: string,
+export function normalizeSubgraphFromString({
   noLocation = true,
-  version: SupportedRouterCompatibilityVersion = ROUTER_COMPATIBILITY_VERSION_ONE,
-): NormalizationResult {
+  options,
+  sdlString,
+  version = ROUTER_COMPATIBILITY_VERSION_ONE,
+}: NormalizeSubgraphFromStringParams): NormalizationResult {
   switch (version) {
     default: {
-      return normalizeSubgraphFromStringV1(schema, noLocation);
+      return normalizeSubgraphFromStringV1({ noLocation, options, sdlString });
     }
   }
 }
 
-export function normalizeSubgraph(
-  document: DocumentNode,
-  subgraphName?: string,
-  internalGraph?: Graph,
-  version: SupportedRouterCompatibilityVersion = ROUTER_COMPATIBILITY_VERSION_ONE,
-): NormalizationResult {
+export function normalizeSubgraph({
+  document,
+  internalGraph,
+  options,
+  subgraphName,
+  version = ROUTER_COMPATIBILITY_VERSION_ONE,
+}: NormalizeSubgraphParams): NormalizationResult {
   switch (version) {
     default: {
-      return normalizeSubgraphV1(document, subgraphName, internalGraph);
+      return normalizeSubgraphV1({ document, internalGraph, options, subgraphName });
     }
   }
 }
 
-export function batchNormalize(
-  subgraphs: Array<Subgraph>,
-  version: SupportedRouterCompatibilityVersion = ROUTER_COMPATIBILITY_VERSION_ONE,
-): BatchNormalizationResult {
+export function batchNormalize({
+  options,
+  subgraphs,
+  version = ROUTER_COMPATIBILITY_VERSION_ONE,
+}: BatchNormalizeParams): BatchNormalizationResult {
   switch (version) {
     default: {
-      return batchNormalizeV1(subgraphs);
+      return batchNormalizeV1({ options, subgraphs });
     }
   }
 }

composition/src/normalization/params.ts

@@ -0,0 +1,27 @@
+import { Subgraph } from '../subgraph/types';
+import { SupportedRouterCompatibilityVersion } from '../router-compatibility-version/router-compatibility-version';
+import { CompositionOptions } from '../types/params';
+import { DocumentNode } from 'graphql';
+import { Graph } from '../resolvability-graph/graph';
+import { SubgraphName } from '../types/types';
+
+export type BatchNormalizeParams = {
+  subgraphs: Array<Subgraph>;
+  options?: CompositionOptions;
+  version?: SupportedRouterCompatibilityVersion;
+};
+
+export type NormalizeSubgraphParams = {
+  document: DocumentNode;
+  internalGraph?: Graph;
+  options?: CompositionOptions;
+  subgraphName?: SubgraphName;
+  version?: SupportedRouterCompatibilityVersion;
+};
+
+export type NormalizeSubgraphFromStringParams = {
+  sdlString: string;
+  noLocation?: boolean;
+  options?: CompositionOptions;
+  version?: SupportedRouterCompatibilityVersion;
+};

composition/src/types/params.ts

@@ -0,0 +1,4 @@
+export type CompositionOptions = {
+  disableResolvabilityValidation?: boolean;
+  ignoreExternalKeys?: boolean;
+};