@apollo/federation

  • Version 0.36.1
  • Published
  • 778 kB
  • 3 dependencies
  • MIT license

Install

npm i @apollo/federation
yarn add @apollo/federation
pnpm add @apollo/federation

Overview

Apollo Federation Utilities

Index

Variables

variable buildFederatedSchema

const buildFederatedSchema: any;

    variable compositionRules

    const compositionRules: any[];

      variable defaultRootOperationNameLookup

      const defaultRootOperationNameLookup: { [x: string]: DefaultRootOperationTypeName };

        Functions

        function addFederationMetadataToSchemaNodes

        addFederationMetadataToSchemaNodes: ({
        schema,
        typeToServiceMap,
        externalFields,
        keyDirectivesMap,
        valueTypes,
        directiveDefinitionsMap,
        directiveMetadata,
        }: {
        schema: GraphQLSchema;
        typeToServiceMap: TypeToServiceMap;
        externalFields: ExternalFieldDefinition[];
        keyDirectivesMap: KeyDirectivesMap;
        valueTypes: ValueTypes;
        directiveDefinitionsMap: DirectiveDefinitionsMap;
        directiveMetadata: DirectiveMetadata;
        }) => void;

          function buildMapsFromServiceList

          buildMapsFromServiceList: (serviceList: ServiceDefinition[]) => {
          typeToServiceMap: TypeToServiceMap;
          typeDefinitionsMap: TypeDefinitionsMap;
          typeExtensionsMap: TypeExtensionsMap;
          directiveDefinitionsMap: DirectiveDefinitionsMap;
          externalFields: ExternalFieldDefinition[];
          keyDirectivesMap: KeyDirectivesMap;
          valueTypes: ValueTypes;
          directiveMetadata: DirectiveMetadata;
          };

            function buildSchemaFromDefinitionsAndExtensions

            buildSchemaFromDefinitionsAndExtensions: ({
            typeDefinitionsMap,
            typeExtensionsMap,
            directiveDefinitionsMap,
            directiveMetadata,
            serviceList,
            }: {
            typeDefinitionsMap: TypeDefinitionsMap;
            typeExtensionsMap: TypeExtensionsMap;
            directiveDefinitionsMap: DirectiveDefinitionsMap;
            directiveMetadata: DirectiveMetadata;
            serviceList: ServiceDefinition[];
            }) => { schema: GraphQLSchema; errors: GraphQLError[] };

              function composeAndValidate

              composeAndValidate: (serviceList: ServiceDefinition[]) => CompositionResult;

                function composeServices

                composeServices: (services: ServiceDefinition[]) => CompositionResult;

                  function compositionHasErrors

                  compositionHasErrors: (
                  compositionResult: CompositionResult
                  ) => compositionResult is CompositionFailure;

                    function findDirectivesOnNode

                    findDirectivesOnNode: (
                    node: ASTNodeWithDirectives,
                    directiveName: string
                    ) => DirectiveNode[];

                      function isStringValueNode

                      isStringValueNode: (node: any) => node is StringValueNode;

                        function normalizeTypeDefs

                        normalizeTypeDefs: (typeDefs: DocumentNode) => DocumentNode;

                          Interfaces

                          interface ExternalFieldDefinition

                          interface ExternalFieldDefinition {}

                            property field

                            field: FieldDefinitionNode;

                              property parentTypeName

                              parentTypeName: string;

                                property serviceName

                                serviceName: string;

                                  interface FederationDirective

                                  interface FederationDirective {}

                                    property directiveDefinitions

                                    directiveDefinitions: {
                                    [serviceName: string]: DirectiveDefinitionNode;
                                    };

                                      interface FederationField

                                      interface FederationField {}

                                        property belongsToValueType

                                        belongsToValueType?: boolean;

                                          property directiveUsages

                                          directiveUsages?: DirectiveUsages;

                                            property provides

                                            provides?: FieldSet;

                                              property requires

                                              requires?: FieldSet;

                                                property serviceName

                                                serviceName?: ServiceName;

                                                  interface FederationType

                                                  interface FederationType {}

                                                    property directiveUsages

                                                    directiveUsages?: DirectiveUsages;

                                                      property externals

                                                      externals?: {
                                                      [serviceName: string]: ExternalFieldDefinition[];
                                                      };

                                                        property isValueType

                                                        isValueType?: boolean;

                                                          property keys

                                                          keys?: ServiceNameToKeyDirectivesMap;

                                                            property serviceName

                                                            serviceName?: ServiceName;

                                                              interface KeyDirectivesMap

                                                              interface KeyDirectivesMap {}

                                                                index signature

                                                                [typeName: string]: ServiceNameToKeyDirectivesMap;

                                                                  interface ServiceDefinition

                                                                  interface ServiceDefinition {}

                                                                    property name

                                                                    name: string;

                                                                      property typeDefs

                                                                      typeDefs: DocumentNode;

                                                                        property url

                                                                        url?: string;

                                                                          interface ServiceNameToKeyDirectivesMap

                                                                          interface ServiceNameToKeyDirectivesMap {}

                                                                            index signature

                                                                            [serviceName: string]: FieldSet[] | undefined;

                                                                              Type Aliases

                                                                              type DefaultRootOperationTypeName

                                                                              type DefaultRootOperationTypeName = 'Query' | 'Mutation' | 'Subscription';

                                                                                type DirectiveUsages

                                                                                type DirectiveUsages = Map<string, DirectiveNode[]>;

                                                                                  type FieldSet

                                                                                  type FieldSet = readonly (FieldNode | InlineFragmentNode)[];

                                                                                    type Maybe

                                                                                    type Maybe<T> = null | undefined | T;

                                                                                      type ServiceName

                                                                                      type ServiceName = string | null;

                                                                                        Package Files (7)

                                                                                        Dependencies (3)

                                                                                        Dev Dependencies (0)

                                                                                        No dev dependencies.

                                                                                        Peer Dependencies (1)

                                                                                        Badge

                                                                                        To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                        You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@apollo/federation.

                                                                                        • Markdown
                                                                                          [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@apollo/federation)
                                                                                        • HTML
                                                                                          <a href="https://www.jsdocs.io/package/@apollo/federation"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>