Edit

UnionTypeComposer

Class that helps to create UnionTypeComposers and provide ability to modify them.

Static methods

static create()

static create<TSrc = any, TCtx = any>(
  typeDef: UnionTypeComposerDefinition<TSrc, TCtx>,
  schemaComposer: SchemaComposer<TCtx>
): UnionTypeComposer<TSrc, TCtx>

Create UnionTypeComposer with adding it by name to the SchemaComposer.

static createTemp()

static createTemp<TSrc = any, TCtx = any>(
  typeDef: UnionTypeComposerDefinition<TSrc, TCtx>,
  schemaComposer: SchemaComposer<TCtx>
): UnionTypeComposer<TSrc, TCtx>

Create UnionTypeComposer without adding it to the SchemaComposer. This method may be useful in plugins, when you need to create type temporary.

Getters

List

List: ListComposer<UnionTypeComposer<TSource, TContext>>;

Get Type wrapped in List modifier

const UserTC = schemaComposer.createUnionTC(`union User = Admin | Client`);
schemaComposer.Query.addFields({
  users1: { type: UserTC.List }, // in SDL: users1: [User]
  users2: { type: UserTC.NonNull.List }, // in SDL: users2: [User!]
  users3: { type: UserTC.NonNull.List.NonNull } // in SDL: users2: [User!]!
});

NonNull

NonNull: NonNullComposer<UnionTypeComposer<TSource, TContext>>;

Get Type wrapped in NonNull modifier

const UserTC = schemaComposer.createUnionTC(`union User = Admin | Client`);
schemaComposer.Query.addFields({
  users1: { type: UserTC.List }, // in SDL: users1: [User]
  users2: { type: UserTC.NonNull.List }, // in SDL: users2: [User!]
  users3: { type: UserTC.NonNull.List.NonNull } // in SDL: users2: [User!]!
});

Properties

schemaComposer

schemaComposer: SchemaComposer<TContext>;

Union Types methods

hasType()

hasType(
  name: ObjectTypeComposerDefinition<any, TContext>
): boolean

getTypes()

getTypes(): Array<ObjectTypeComposerThunked<TSource, TContext>>

getTypeComposers()

getTypeComposers(): Array<ObjectTypeComposer<TSource, TContext>>

getTypeNames()

getTypeNames(): string[]

clearTypes()

clearTypes(): this

setTypes()

setTypes(
  types: ReadonlyArray<ObjectTypeComposerThunked<TSource, TContext> | ObjectTypeComposerDefinition<any, TContext>>
): this

addType()

addType(
  type: ObjectTypeComposerThunked<any, TContext> | ObjectTypeComposerDefinition<any, TContext>
): this

addTypes()

addTypes(
  types: ReadonlyArray<ObjectTypeComposerThunked<any, TContext> | ObjectTypeComposerDefinition<any, TContext>>
): this

removeType()

removeType(
  nameOrArray: string | string[]
): this

removeOtherTypes()

removeOtherTypes(
  nameOrArray: string | string[]
): this

Type methods

getType()

getType(): GraphQLUnionType

getTypePlural()

getTypePlural(): ListComposer<UnionTypeComposer<TSource, TContext>>

getTypeNonNull()

getTypeNonNull(): NonNullComposer<UnionTypeComposer<TSource, TContext>>

getTypeName()

getTypeName(): string

setTypeName()

setTypeName(
  name: string
): this

getDescription()

getDescription(): string

setDescription()

setDescription(
  description: string
): this

clone()

clone(
  newTypeNameOrTC: string | UnionTypeComposer<any, any>
): UnionTypeComposer<any, TContext>

You may clone this type with a new provided name as string. Or you may provide a new TypeComposer which will get all cloned settings from this type.

cloneTo()

cloneTo(
  anotherSchemaComposer: SchemaComposer<any>,
  cloneMap: Map<any, any>
): UnionTypeComposer<any, any>

Clone this type to another SchemaComposer. Also will be cloned all sub-types.

merge()

merge(
  type: GraphQLUnionType | UnionTypeComposer<any, any>
): this

ResolveType methods

getResolveType()

getResolveType(): GraphQLTypeResolver<TSource, TContext> | undefined | null

setResolveType()

setResolveType(
  fn: GraphQLTypeResolver<TSource, TContext> | undefined | null
): this

hasTypeResolver()

hasTypeResolver(
  type: ObjectTypeComposerThunked<any, TContext> | ObjectTypeComposerDefinition<any, TContext>
): boolean

getTypeResolvers()

getTypeResolvers(): UnionTypeComposerResolversMap<TSource, TContext>

getTypeResolverCheckFn()

getTypeResolverCheckFn(
  type: ObjectTypeComposerThunked<any, TContext> | ObjectTypeComposerDefinition<any, TContext>
): UnionTypeComposerResolverCheckFn<any, TContext>

getTypeResolverNames()

getTypeResolverNames(): string[]

getTypeResolverTypes()

getTypeResolverTypes(): Array<ObjectTypeComposerThunked<any, TContext>>

setTypeResolvers()

setTypeResolvers(
  typeResolversMap: UnionTypeComposerResolversMapDefinition<TSource, TContext>
): this

addTypeResolver()

addTypeResolver(
  type: ObjectTypeComposerDefinition<any, TContext>,
  checkFn: UnionTypeComposerResolverCheckFn<TSource, TContext>
): this

removeTypeResolver()

removeTypeResolver(
  type: ObjectTypeComposerDefinition<any, TContext>
): this

setTypeResolverFallback()

setTypeResolverFallback(
  type: ObjectTypeComposer<any, TContext> | GraphQLObjectType | null
): this

Extensions methods

Extensions is a property on type/field/arg definitions to pass private extra metadata. It's used only on the server-side with the Code-First approach, mostly for 3rd party server middlewares & plugins. Property extensions may contain private server metadata of any type (even functions) and does not available via SDL.

@see https://github.com/graphql/graphql-js/issues/1527 @note If you need to provide public metadata to clients then use directives instead.

getExtensions()

getExtensions(): Extensions

setExtensions()

setExtensions(
  extensions: Extensions | undefined
): this

extendExtensions()

extendExtensions(
  extensions: Extensions
): this

clearExtensions()

clearExtensions(): this

getExtension()

getExtension(
  extensionName: string
): unknown

hasExtension()

hasExtension(
  extensionName: string
): boolean

setExtension()

setExtension(
  extensionName: string,
  value: unknown
): this

removeExtension()

removeExtension(
  extensionName: string
): this

Directive methods

Directives provide the ability to work with public metadata which is available via SDL. Directives can be used on type/field/arg definitions. The most famous directives are @deprecated(reason: "...") and @specifiedBy(url: "...") which are present in GraphQL spec. GraphQL spec allows to you add any own directives.

@example type Article @directive1 { name @directive2 comments(limit: Int @directive3) }

@note If you need private metadata then use extensions instead.

getDirectives()

getDirectives(): Array<Directive>

setDirectives()

setDirectives(
  directives: Array<Directive>
): this

getDirectiveNames()

getDirectiveNames(): string[]

getDirectiveByName()

getDirectiveByName(
  directiveName: string
): DirectiveArgs | undefined

Returns arguments of first found directive by name. If directive does not exists then will be returned undefined.

setDirectiveByName()

setDirectiveByName(
  directiveName: string,
  args: DirectiveArgs
): this

Set arguments of first found directive by name. If directive does not exists then will be created new one.

getDirectiveById()

getDirectiveById(
  idx: number
): DirectiveArgs | undefined

Misc methods

getNestedTCs()

getNestedTCs(
  opts: {
      exclude?: string[] | undefined;
  },
  passedTypes: Set<NamedTypeComposer<any>>
): Set<NamedTypeComposer<any>>

Returns all types which are used inside the current type

toSDL()

toSDL(
  opts: SchemaPrinterOptions & {
      deep?: boolean;
      exclude?: string[];
  }
): string

Prints SDL for current type. Or print with all used types if deep: true option was provided.

Internal type definitions

UnionTypeComposerDefinition

export type UnionTypeComposerDefinition<TSource, TContext> =
  | TypeDefinitionString
  | TypeNameString
  | UnionTypeComposerAsObjectDefinition<TSource, TContext>
  | GraphQLUnionType;

UnionTypeComposerAsObjectDefinition

export type UnionTypeComposerAsObjectDefinition<TSource, TContext> = {
  name: string;
  types?: Thunk<ReadonlyArray<ObjectTypeComposerDefinition<any, TContext>> | null>;
  resolveType?: GraphQLTypeResolver<TSource, TContext> | null;
  description?: string | null;
  extensions?: Extensions;
  directives?: Directive[];
};

UnionTypeComposerResolversMap

export type UnionTypeComposerResolversMap<TSource, TContext> = Map<
  ObjectTypeComposerThunked<TSource, TContext>,
  UnionTypeComposerResolverCheckFn<TSource, TContext>
>;

UnionTypeComposerResolversMapDefinition

export type UnionTypeComposerResolversMapDefinition<TSource, TContext> =
  | Map<
      ObjectTypeComposerThunked<any, TContext> | ObjectTypeComposerDefinition<any, TContext>,
      UnionTypeComposerResolverCheckFn<TSource, TContext>
    >
  | Readonly<UnionTypeComposerResolversMap<TSource, TContext>>;

UnionTypeComposerResolverCheckFn

export type UnionTypeComposerResolverCheckFn<TSource, TContext> = (
  value: TSource,
  context: TContext,
  info: GraphQLResolveInfo
) => MaybePromise<boolean | null | undefined>;

UnionTypeComposerThunked

export type UnionTypeComposerThunked<TReturn, TContext> =
  | UnionTypeComposer<TReturn, TContext>
  | ThunkComposer<UnionTypeComposer<TReturn, TContext>, GraphQLUnionType>;