Edit

ObjectTypeComposer

Main class that gets GraphQLObjectType and provide ability to change them.

Static methods

static create()

static create<TSrc = any, TCtx = any>(
  typeDef: ObjectTypeComposeDefinition<TSrc, TCtx>,
  schemaComposer: SchemaComposer<TCtx>
): ObjectTypeComposer<TSrc, TCtx>

Create ObjectTypeComposer with adding it by name to the SchemaComposer.

static createTemp()

static createTemp<TSrc = any, TCtx = any>(
  typeDef: ObjectTypeComposeDefinition<TSrc, TCtx>,
  schemaComposer: SchemaComposer<TCtx>
): ObjectTypeComposer<TSrc, TCtx>

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

Properties

schemaComposer

schemaComposer: SchemaComposer<TContext>;

Field methods

getFields()

getFields(): ComposeFieldConfigMap<TSource, TContext>

getFieldNames()

getFieldNames(): string[]

setFields()

setFields(
  fields: ComposeFieldConfigMap<TSource, TContext>
): this

hasField()

hasField(
  fieldName: string
): boolean

setField()

setField<TArgs = ArgsMap>(
  fieldName: string,
  fieldConfig: ComposeFieldConfig<TSource, TContext, TArgs>
): this

addFields()

addFields(
  newFields: ComposeFieldConfigMap<TSource, TContext>
): this

Add new fields or replace existed in a GraphQL type

addNestedFields()

addNestedFields(
  newFields: ComposeFieldConfigMap<TSource, TContext>
): this

Add new fields or replace existed (where field name may have dots)

getField()

getField<TArgs = ArgsMap>(
  fieldName: string
): ComposeFieldConfig<TSource, TContext, TArgs>

removeField()

removeField(
  fieldNameOrArray: string | string[]
): this

removeOtherFields()

removeOtherFields(
  fieldNameOrArray: string | string[]
): this

extendField()

extendField<TArgs = ArgsMap>(
  fieldName: string,
  partialFieldConfig: Partial<ComposeFieldConfig<TSource, TContext, TArgs>>
): this

reorderFields()

reorderFields(
  names: string[]
): this

isFieldNonNull()

isFieldNonNull(
  fieldName: string
): boolean

getFieldConfig()

getFieldConfig(
  fieldName: string
): GraphQLFieldConfig<TSource, TContext>

getFieldType()

getFieldType(
  fieldName: string
): GraphQLOutputType

getFieldTC()

getFieldTC(
  fieldName: string
):
  | ObjectTypeComposer<TSource, TContext>
  | InputTypeComposer<TContext>
  | EnumTypeComposer<TContext>
  | InterfaceTypeComposer<TSource, TContext>
  | UnionTypeComposer<TSource, TContext>
  | ScalarTypeComposer<TContext>

makeFieldNonNull()

makeFieldNonNull(
  fieldNameOrArray: string | string[]
): this

makeFieldNullable()

makeFieldNullable(
  fieldNameOrArray: string | string[]
): this

deprecateFields()

deprecateFields(
  fields: {
      [fieldName: string]: string;
  } | string[] | string
): this

getFieldArgs()

getFieldArgs(
  fieldName: string
): GraphQLFieldConfigArgumentMap

hasFieldArg()

hasFieldArg(
  fieldName: string,
  argName: string
): boolean

getFieldArg()

getFieldArg(
  fieldName: string,
  argName: string
): GraphQLArgumentConfig

getFieldArgType()

getFieldArgType(
  fieldName: string,
  argName: string
): GraphQLInputType

Type methods

getType()

getType(): GraphQLObjectType

getTypePlural()

getTypePlural(): GraphQLList<GraphQLObjectType>

getTypeNonNull()

getTypeNonNull(): GraphQLNonNull<GraphQLObjectType>

getTypeName()

getTypeName(): string

setTypeName()

setTypeName(
  name: string
): this

getDescription()

getDescription(): string

setDescription()

setDescription(
  description: string
): this

clone()

clone<TCloneSource = TSource>(
  newTypeName: string
): ObjectTypeComposer<TCloneSource, TContext>

getIsTypeOf()

getIsTypeOf(): GraphQLIsTypeOfFn<TSource, TContext> | null | void

setIsTypeOf()

setIsTypeOf(
  fn: GraphQLIsTypeOfFn<any, any> | null | void
): this

InputType methods

getInputType()

getInputType(): GraphQLInputObjectType

hasInputTypeComposer()

hasInputTypeComposer(): boolean

setInputTypeComposer()

setInputTypeComposer(
  itc: InputTypeComposer<TContext>
): this

getInputTypeComposer()

getInputTypeComposer(): InputTypeComposer<TContext>

getITC()

getITC(): InputTypeComposer<TContext>

removeInputTypeComposer()

removeInputTypeComposer(): this

Resolver methods

getResolvers()

getResolvers(): Map<string, Resolver<any, TContext, any>>

hasResolver()

hasResolver(
  name: string
): boolean

getResolver()

getResolver<TResolverSource = any, TArgs = ArgsMap>(
  name: string,

  // type ResolverMiddleware = (resolve, source, args, context, info) => any;
  middlewares: Array<ResolverMiddleware<TResolverSource, TContext, TArgs>>
): Resolver<TResolverSource, TContext, TArgs>

Returns existed Resolver by name.

Resolver may be additionally wrapped by middlewares. Eg:

async function authMiddleware(resolve, source, args, context, info) {
  if (somehowCheckAuthInContext(context)) {
    return resolve(source, args, context, info);
  }
  throw new Error('You must be authorized');
}

schemaComposer.Query.addFields({
  userById: UserTC.getResolver('findById', [authMiddleware]),
  userByIds: UserTC.getResolver('findByIds', [authMiddleware])
});

setResolver()

setResolver<TResolverSource = any, TArgs = ArgsMap>(
  name: string,
  resolver: Resolver<TResolverSource, TContext, TArgs>
): this

addResolver()

addResolver<TResolverSource = any, TArgs = ArgsMap>(
  resolver: Resolver<TResolverSource, TContext, TArgs> | ResolverOpts<TResolverSource, TContext, TArgs>
): this

removeResolver()

removeResolver(
  resolverName: string
): this

wrapResolver()

wrapResolver<TResolverSource = any, TArgs = ArgsMap>(
  resolverName: string,
  cbResolver: ResolverWrapCb<TResolverSource, TSource, TContext, TArgs>
): this

wrapResolverAs()

wrapResolverAs<TResolverSource = any, TArgs = ArgsMap>(
  resolverName: string,
  fromResolverName: string,
  cbResolver: ResolverWrapCb<TResolverSource, TSource, TContext, TArgs>
): this

wrapResolverResolve()

wrapResolverResolve<TResolverSource = any, TArgs = ArgsMap>(
  resolverName: string,
  cbNextRp: ResolverNextRpCb<TResolverSource, TContext, TArgs>
): this

Interface methods

getInterfaces()

getInterfaces(): Array<
  InterfaceTypeComposer<any, TContext> | GraphQLInterfaceType
>

setInterfaces()

setInterfaces(
  interfaces: Array<InterfaceTypeComposer<any, TContext> | GraphQLInterfaceType>
): this

hasInterface()

hasInterface(
  iface: string | InterfaceTypeComposer<any, TContext> | GraphQLInterfaceType
): boolean

addInterface()

addInterface(
  interfaceObj: InterfaceTypeComposer<any, TContext> | GraphQLInterfaceType
): this

removeInterface()

removeInterface(
  interfaceObj: InterfaceTypeComposer<any, TContext> | GraphQLInterfaceType
): this

Extensions methods

getExtensions()

getExtensions(): Extensions

setExtensions()

setExtensions(
  extensions: Extensions
): this

extendExtensions()

extendExtensions(
  extensions: Extensions
): this

clearExtensions()

clearExtensions(): this

getExtension()

getExtension(
  extensionName: string
): any

hasExtension()

hasExtension(
  extensionName: string
): boolean

setExtension()

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

removeExtension()

removeExtension(
  extensionName: string
): this

getFieldExtensions()

getFieldExtensions(
  fieldName: string
): Extensions

setFieldExtensions()

setFieldExtensions(
  fieldName: string,
  extensions: Extensions
): this

extendFieldExtensions()

extendFieldExtensions(
  fieldName: string,
  extensions: Extensions
): this

clearFieldExtensions()

clearFieldExtensions(
  fieldName: string
): this

getFieldExtension()

getFieldExtension(
  fieldName: string,
  extensionName: string
): any

hasFieldExtension()

hasFieldExtension(
  fieldName: string,
  extensionName: string
): boolean

setFieldExtension()

setFieldExtension(
  fieldName: string,
  extensionName: string,
  value: any
): this

removeFieldExtension()

removeFieldExtension(
  fieldName: string,
  extensionName: string
): this

Misc methods

addRelation()

addRelation<TRelationSource = any, TArgs = ArgsMap>(
  fieldName: string,
  relationOpts: RelationOpts<TRelationSource, TSource, TContext, TArgs>
): this

getRelations()

getRelations(): RelationThunkMap<any, TContext>

setRecordIdFn()

setRecordIdFn(
  fn: GetRecordIdFn<TSource, TContext>
): this

hasRecordIdFn()

hasRecordIdFn(): boolean

getRecordIdFn()

getRecordIdFn(): GetRecordIdFn<TSource, TContext>

getRecordId()

getRecordId(
  source: TSource,
  args: ArgsMap,
  context: TContext
): string | number

Get function that returns record id, from provided object.

get()

get(
  path: string | string[]
): any

Internal type definitions

GetRecordIdFn

export type GetRecordIdFn<TSource, TContext> = (
  source: TSource,
  args: any,
  context: TContext,
) => string;

GraphQLObjectTypeExtended

export type GraphQLObjectTypeExtended<TSource, TContext> = GraphQLObjectType & {
  _gqcInputTypeComposer?: InputTypeComposer<TContext>;
  _gqcResolvers?: Map<string, Resolver<TSource, TContext>>;
  _gqcGetRecordIdFn?: GetRecordIdFn<TSource, TContext>;
  _gqcRelations?: RelationThunkMap<TSource, TContext>;
  _gqcFields?: ComposeFieldConfigMap<TSource, TContext>;
  _gqcInterfaces?: Array<
    GraphQLInterfaceType | InterfaceTypeComposer<any, TContext>
  >;
  _gqcExtensions?: Extensions;
  description: string | null;
};

ComposeObjectTypeConfig

export type ComposeObjectTypeConfig<TSource, TContext> = {
  name: string;
  interfaces?: Thunk<GraphQLInterfaceType[] | null>;
  fields?: Thunk<ComposeFieldConfigMap<TSource, TContext>>;
  isTypeOf?: GraphQLIsTypeOfFn<TSource, TContext> | null;
  description?: string | null;
  isIntrospection?: boolean;
  extensions?: Extensions;
};

ComposeFieldConfigMap

// extended GraphQLFieldConfigMap
export type ComposeFieldConfigMap<TSource, TContext> = ObjMap<
  ComposeFieldConfig<TSource, TContext>
>;

ComposeFieldConfig

export type ComposeFieldConfig<TSource, TContext, TArgs = ArgsMap> =
  | ComposeFieldConfigAsObject<TSource, TContext, TArgs>
  | ComposeOutputType<any /* TReturn */, TContext>
  | Thunk<
      | ComposeFieldConfigAsObject<TSource, TContext, TArgs>
      | ComposeOutputType<any /* TReturn */, TContext>
    >;

GraphqlFieldConfigExtended

// extended GraphQLFieldConfig
export type GraphqlFieldConfigExtended<TSource, TContext> = GraphQLFieldConfig<
  TSource,
  TContext
> & { projection?: any };

ComposeFieldConfigAsObject

export type ComposeFieldConfigAsObject<TSource, TContext, TArgs = ArgsMap> = {
  type:
    | Thunk<ComposeOutputType<any /* TReturn */, TContext>>
    | GraphQLOutputType;
  args?: ComposeFieldConfigArgumentMap<TArgs>;
  resolve?: GraphQLFieldResolver<TSource, TContext, TArgs>;
  subscribe?: GraphQLFieldResolver<TSource, TContext>;
  deprecationReason?: string | null;
  description?: string | null;
  astNode?: FieldDefinitionNode | null;
  extensions?: Extensions;
  [key: string]: any;
} & { $call?: void };

ComposeOutputType

// Output type should not have `TSource`. It should not affect on main Type source!
// extended GraphQLOutputType
export type ComposeOutputType<TReturn, TContext> =
  | GraphQLOutputType
  | ObjectTypeComposer<TReturn, TContext>
  | EnumTypeComposer<TContext>
  | ScalarTypeComposer<TContext>
  | TypeAsString
  | Resolver<any, TContext, any>
  | InterfaceTypeComposer<TReturn, TContext>
  | UnionTypeComposer<TReturn, TContext>
  | Array<
      | GraphQLOutputType
      | ObjectTypeComposer<TReturn, TContext>
      | EnumTypeComposer<TContext>
      | ScalarTypeComposer<TContext>
      | TypeAsString
      | Resolver<any, TContext, any>
      | InterfaceTypeComposer<TReturn, TContext>
      | UnionTypeComposer<TReturn, TContext>
    >;

ArgsMap

// Compose Args -----------------------------

export type ArgsMap = { [argName: string]: any };

ComposeArgumentType

export type ComposeArgumentType =
  | GraphQLInputType
  | TypeAsString
  | InputTypeComposer<any>
  | EnumTypeComposer<any>
  | ScalarTypeComposer<any>
  | Array<
      | GraphQLInputType
      | TypeAsString
      | InputTypeComposer<any>
      | EnumTypeComposer<any>
      | ScalarTypeComposer<any>
    >;

ComposeArgumentConfigAsObject

export type ComposeArgumentConfigAsObject = {
  type: Thunk<ComposeArgumentType> | GraphQLInputType;
  defaultValue?: any;
  description?: string | null;
  astNode?: InputValueDefinitionNode | null;
} & { $call?: void };

ComposeArgumentConfig

export type ComposeArgumentConfig =
  | ComposeArgumentConfigAsObject
  | ComposeArgumentType
  | (() => ComposeArgumentConfigAsObject | ComposeArgumentType);

ComposeFieldConfigArgumentMap

export type ComposeFieldConfigArgumentMap<TArgs = ArgsMap> = {
  [argName in keyof TArgs]: ComposeArgumentConfig
};

RelationThunkMap

// RELATION -----------------------------

export type RelationThunkMap<TSource, TContext> = {
  [fieldName: string]: Thunk<RelationOpts<TSource, TContext, ArgsMap>>;
};

RelationOpts

export type RelationOpts<TRelationSource, TSource, TContext, TArgs = ArgsMap> =
  | RelationOptsWithResolver<TRelationSource, TSource, TContext, TArgs>
  | RelationOptsWithFieldConfig<TSource, TContext, TArgs>;

RelationOptsWithResolver

export type RelationOptsWithResolver<
  TRelationSource,
  TSource,
  TContext,
  TArgs = ArgsMap
> = {
  resolver: Thunk<Resolver<TRelationSource, TContext, TArgs>>;
  prepareArgs?: RelationArgsMapper<TSource, TContext, TArgs>;
  projection?: Partial<ProjectionType>;
  description?: string | null;
  deprecationReason?: string | null;
  catchErrors?: boolean;
};

RelationOptsWithFieldConfig

export type RelationOptsWithFieldConfig<
  TSource,
  TContext,
  TArgs = ArgsMap
> = ComposeFieldConfigAsObject<TSource, TContext, TArgs> & {
  resolve: GraphQLFieldResolver<TSource, TContext, TArgs>;
};

RelationArgsMapperFn

export type RelationArgsMapperFn<TSource, TContext, TArgs = ArgsMap> = (
  source: TSource,
  args: TArgs,
  context: TContext,
  info: GraphQLResolveInfo,
) => any;

RelationArgsMapper

export type RelationArgsMapper<TSource, TContext, TArgs = ArgsMap> = {
  [argName: string]:
    | { [key: string]: any }
    | RelationArgsMapperFn<TSource, TContext, TArgs>
    | null
    | void
    | string
    | number
    | any[];
};

ObjectTypeComposeDefinition

export type ObjectTypeComposeDefinition<TSource, TContext> =
  | TypeAsString
  | ComposeObjectTypeConfig<TSource, TContext>
  | GraphQLObjectType;