@graphql-codegen/visitor-plugin-common

@graphql-codegen/visitor-plugin-common

Version 2.8.0
Published 8 days ago
369 kB
10 dependencies
MIT license

Install

npm i @graphql-codegen/visitor-plugin-common

yarn add @graphql-codegen/visitor-plugin-common

pnpm add @graphql-codegen/visitor-plugin-common

Overview

Overview not available.

Index

Variables

variable DEFAULT_AVOID_OPTIONALS

const DEFAULT_AVOID_OPTIONALS: AvoidOptionalsConfig;

variable DEFAULT_DECLARATION_KINDS

const DEFAULT_DECLARATION_KINDS: DeclarationKindConfig;

variable DEFAULT_SCALARS

const DEFAULT_SCALARS: NormalizedScalarsMap;

variable OMIT_TYPE

const OMIT_TYPE: string;

variable REQUIRE_FIELDS_TYPE

const REQUIRE_FIELDS_TYPE: string;

Functions

function block

block: (array: any) => string;

function breakLine

breakLine: (str: string) => string;

function buildMapperImport

buildMapperImport: (
    source: string,
    types: { identifier: string; asDefault?: boolean }[],
    useTypeImports: boolean
) => string | null;

function buildScalars

buildScalars: (
    schema: GraphQLSchema | undefined,
    scalarsMapping: ScalarsMap,
    defaultScalarsMapping?: NormalizedScalarsMap,
    defaultScalarType?: string | null
) => ParsedScalarsMap;

function buildScalarsFromConfig

buildScalarsFromConfig: (
    schema: GraphQLSchema | undefined,
    config: RawConfig,
    defaultScalarsMapping?: NormalizedScalarsMap,
    defaultScalarType?: string
) => ParsedScalarsMap;

function clearExtension

clearExtension: (path: string) => string;

function convertFactory

convertFactory: (config: { namingConvention?: NamingConvention }) => ConvertFn;

function convertNameParts

convertNameParts: (
    str: string,
    func: (str: string) => string,
    removeUnderscore?: boolean
) => string;

function fixLocalFilePath

fixLocalFilePath: (path: string) => string;

function generateFragmentImportStatement

generateFragmentImportStatement: (
    statement: ImportDeclaration<FragmentImport>,
    kind: 'type' | 'document' | 'both'
) => string;

function generateImportStatement

generateImportStatement: (statement: ImportDeclaration) => string;

function getBaseTypeNode

getBaseTypeNode: (typeNode: TypeNode) => NamedTypeNode;

function getConfigValue

getConfigValue: <T = any>(value: T, defaultValue: T) => T;

function getFieldNodeNameValue

getFieldNodeNameValue: (node: FieldNode) => string;

function getPossibleTypes

getPossibleTypes: (
    schema: GraphQLSchema,
    type: GraphQLNamedType
) => GraphQLObjectType[];

function getRootTypeNames

getRootTypeNames: (schema: GraphQLSchema) => string[];

function hasConditionalDirectives

hasConditionalDirectives: (field: FieldNode) => boolean;

function indent

indent: (str: string, count?: number) => string;

function indentMultiline

indentMultiline: (str: string, count?: number) => string;

function isExternalMapper

isExternalMapper: (value: string) => boolean;

function isExternalMapperType

isExternalMapperType: (m: ParsedMapper) => m is ExternalParsedMapper;

function mergeSelectionSets

mergeSelectionSets: (
    selectionSet1: SelectionSetNode,
    selectionSet2: SelectionSetNode
) => SelectionSetNode;

merge selection sets into a new selection set without mutating the inputs.

function normalizeAvoidOptionals

normalizeAvoidOptionals: (
    avoidOptionals?: boolean | AvoidOptionalsConfig
) => AvoidOptionalsConfig;

function normalizeDeclarationKind

normalizeDeclarationKind: (
    declarationKind?: DeclarationKind | DeclarationKindConfig
) => DeclarationKindConfig;

function optimizeOperations

optimizeOperations: (
    schema: GraphQLSchema,
    documents: Types.DocumentFile[],
    options?: { includeFragments: boolean }
) => Types.DocumentFile[];

function parseEnumValues

parseEnumValues: ({
    schema,
    mapOrStr,
    ignoreEnumValuesFromSchema,
}: {
    schema: GraphQLSchema;
    mapOrStr: EnumValuesMap;
    ignoreEnumValuesFromSchema?: boolean;
}) => ParsedEnumValuesMap;

function parseMapper

parseMapper: (
    mapper: string,
    gqlTypeName?: string | null,
    suffix?: string
) => ParsedMapper;

function quoteIfNeeded

quoteIfNeeded: (array: string[], joinWith?: string) => string;

function removeDescription

removeDescription: <T extends { description?: StringValueNode }>(
    nodes: readonly T[]
) => (T & { description: any })[];

function resolveImportSource

resolveImportSource: <T>(source: string | ImportSource<T>) => ImportSource<T>;

function resolveRelativeImport

resolveRelativeImport: (from: string, to: string) => string;

function separateSelectionSet

separateSelectionSet: (selections: ReadonlyArray<SelectionNode>) => {
    fields: FieldNode[];
    spreads: FragmentSpreadNode[];
    inlines: InlineFragmentNode[];
};

function stripMapperTypeInterpolation

stripMapperTypeInterpolation: (identifier: string) => string;

function transformComment

transformComment: (
    comment: string | StringValueNode,
    indentLevel?: number,
    disabled?: boolean
) => string;

function transformDirectiveArgumentAndInputFieldMappings

transformDirectiveArgumentAndInputFieldMappings: (
    rawDirectiveArgumentAndInputFieldMappings: DirectiveArgumentAndInputFieldMappings,
    directiveArgumentAndInputFieldMappingTypeSuffix?: string
) => ParsedDirectiveArgumentAndInputFieldMappings;

function transformMappers

transformMappers: (
    rawMappers: RawResolversConfig['mappers'],
    mapperTypeSuffix?: string
) => ParsedResolversConfig['mappers'];

function wrapTypeNodeWithModifiers

wrapTypeNodeWithModifiers: (baseType: string, typeNode: TypeNode) => string;

function wrapTypeWithModifiers

wrapTypeWithModifiers: (
    baseType: string,
    type: GraphQLOutputType | GraphQLNamedType,
    options: WrapModifiersOptions
) => string;

function wrapWithSingleQuotes

wrapWithSingleQuotes: (
    value: string | number | NameNode,
    skipNumericCheck?: boolean
) => string;

Classes

class BaseDocumentsVisitor

class BaseDocumentsVisitor<
    TRawConfig extends RawDocumentsConfig = RawDocumentsConfig,
    TPluginConfig extends ParsedDocumentsConfig = ParsedDocumentsConfig
> extends BaseVisitor<TRawConfig, TPluginConfig> {}

constructor

constructor(
    rawConfig: RawDocumentsConfig,
    additionalConfig: ParsedDocumentsConfig,
    _schema: GraphQLSchema,
    defaultScalars?: NormalizedScalarsMap
);

property addTypename

readonly addTypename: boolean;

property schema

readonly schema: GraphQLSchema;

method applyVariablesWrapper

protected applyVariablesWrapper: (variablesBlock: string) => string;

method FragmentDefinition

FragmentDefinition: (node: FragmentDefinitionNode) => string;

method getGlobalDeclarations

getGlobalDeclarations: (noExport?: boolean) => string[];

method OperationDefinition

OperationDefinition: (node: OperationDefinitionNode) => string;

method setDeclarationBlockConfig

setDeclarationBlockConfig: (config: DeclarationBlockConfig) => void;

method setSelectionSetHandler

setSelectionSetHandler: (handler: SelectionSetToObject) => void;

method setVariablesTransformer

setVariablesTransformer: (
    variablesTransfomer: OperationVariablesToObject
) => void;

class BaseResolversVisitor

class BaseResolversVisitor<
    TRawConfig extends RawResolversConfig = RawResolversConfig,
    TPluginConfig extends ParsedResolversConfig = ParsedResolversConfig
> extends BaseVisitor<TRawConfig, TPluginConfig> {}

constructor

constructor(
    rawConfig: RawResolversConfig,
    additionalConfig: ParsedResolversConfig,
    _schema: GraphQLSchema,
    defaultScalars?: NormalizedScalarsMap
);

property defaultMapperType

readonly defaultMapperType: string;

property globalDeclarations

readonly globalDeclarations: string[];

property mappersImports

readonly mappersImports: string[];

property schema

readonly schema: GraphQLSchema;

property unusedMappers

readonly unusedMappers: string[];

method applyMaybe

protected applyMaybe: (str: string) => string;

method applyOptionalFields

protected applyOptionalFields: (
    argsType: string,
    _fields: readonly InputValueDefinitionNode[]
) => string;

method applyRequireFields

protected applyRequireFields: (
    argsType: string,
    fields: InputValueDefinitionNode[]
) => string;

method applyResolverTypeWrapper

protected applyResolverTypeWrapper: (str: string) => string;

method buildEnumResolverContentBlock

protected buildEnumResolverContentBlock: (
    _node: EnumTypeDefinitionNode,
    _mappedEnumType: string
) => string;

method buildEnumResolversExplicitMappedValues

protected buildEnumResolversExplicitMappedValues: (
    _node: EnumTypeDefinitionNode,
    _valuesMapping: { [valueName: string]: string | number }
) => string;

method buildResolversParentTypes

buildResolversParentTypes: () => string;

method buildResolversTypes

buildResolversTypes: () => string;

method clearMaybe

protected clearMaybe: (str: string) => string;

method clearResolverTypeWrapper

protected clearResolverTypeWrapper: (str: string) => string;

method convertName

convertName: (
    node: ASTNode | string,
    options?: BaseVisitorConvertOptions & ConvertOptions,
    applyNamespacedImport?: boolean
) => string;

method createDirectivedContextType

protected createDirectivedContextType: () => FieldContextTypeMap;

method createFieldContextTypeMap

protected createFieldContextTypeMap: () => FieldContextTypeMap;

method createResolversFields

protected createResolversFields: (
    applyWrapper: (str: string) => string,
    clearWrapper: (str: string) => string,
    getTypeToUse: (str: string) => string,
    shouldInclude?: (type: GraphQLNamedType) => boolean
) => ResolverTypes;

method DirectiveDefinition

DirectiveDefinition: (
    node: DirectiveDefinitionNode,
    key: string | number,
    parent: any
) => string;

method EnumTypeDefinition

EnumTypeDefinition: (node: EnumTypeDefinitionNode) => string;

method FieldDefinition

FieldDefinition: (
    node: FieldDefinitionNode,
    key: string | number,
    parent: any
) => (parentName: string) => string | null;

method formatRootResolver

protected formatRootResolver: (
    schemaTypeName: string,
    resolverType: string,
    declarationKind: DeclarationKind
) => string;

method getAllDirectiveResolvers

getAllDirectiveResolvers: () => string;

method getParentTypeForSignature

protected getParentTypeForSignature: (_node: FieldDefinitionNode) => string;

method getParentTypeToUse

protected getParentTypeToUse: (name: string) => string;

method getResolverTypeWrapperSignature

getResolverTypeWrapperSignature: () => string;

method getRootResolver

getRootResolver: () => string;

method getTypeToUse

protected getTypeToUse: (name: string) => string;

method hasFederation

hasFederation: () => boolean;

method hasScalars

hasScalars: () => boolean;

method InterfaceTypeDefinition

InterfaceTypeDefinition: (node: InterfaceTypeDefinitionNode) => string;

method isMapperImported

protected isMapperImported: (
    groupedMappers: GroupedMappers,
    identifier: string,
    source: string
) => boolean;

method ListType

ListType: (node: ListTypeNode) => string;

method markMapperAsUsed

protected markMapperAsUsed: (name: string) => void;

method Name

Name: (node: NameNode) => string;

method NamedType

NamedType: (node: NamedTypeNode) => string;

method NonNullType

NonNullType: (node: NonNullTypeNode) => string;

method ObjectTypeDefinition

ObjectTypeDefinition: (node: ObjectTypeDefinitionNode) => string;

method replaceFieldsInType

protected replaceFieldsInType: (
    typeName: string,
    relevantFields: {
        addOptionalSign: boolean;
        fieldName: string;
        replaceWithType: string;
    }[]
) => string;

method ScalarTypeDefinition

ScalarTypeDefinition: (node: ScalarTypeDefinitionNode) => string;

method SchemaDefinition

SchemaDefinition: () => any;

method setDeclarationBlockConfig

setDeclarationBlockConfig: (config: DeclarationBlockConfig) => void;

method setVariablesTransformer

setVariablesTransformer: (
    variablesTransfomer: OperationVariablesToObject
) => void;

method shouldMapType

protected shouldMapType: (
    type: GraphQLNamedType,
    duringCheck?: string[]
) => boolean;

method transformParentGenericType

protected transformParentGenericType: (parentType: string) => string;

method UnionTypeDefinition

UnionTypeDefinition: (
    node: UnionTypeDefinitionNode,
    key: string | number,
    parent: any
) => string;

method wrapWithArray

protected wrapWithArray: (t: string) => string;

class BaseSelectionSetProcessor

class BaseSelectionSetProcessor<Config extends SelectionSetProcessorConfig> {}

constructor

constructor(config: SelectionSetProcessorConfig);

property config

config: SelectionSetProcessorConfig;

method buildFieldsIntoObject

buildFieldsIntoObject: (allObjectsMerged: string[]) => string;

method buildSelectionSetFromStrings

buildSelectionSetFromStrings: (pieces: string[]) => string;

method transformAliasesPrimitiveFields

transformAliasesPrimitiveFields: (
    _schemaType: GraphQLObjectType | GraphQLInterfaceType,
    _fields: PrimitiveAliasedFields[]
) => (string | NameAndType)[];

method transformLinkFields

transformLinkFields: (_fields: LinkField[]) => (string | NameAndType)[];

method transformPrimitiveFields

transformPrimitiveFields: (
    _schemaType: GraphQLObjectType | GraphQLInterfaceType,
    _fields: PrimitiveField[]
) => (string | NameAndType)[];

method transformTypenameField

transformTypenameField: (
    _type: string,
    _name: string
) => (string | NameAndType)[];

class BaseTypesVisitor

class BaseTypesVisitor<
    TRawConfig extends RawTypesConfig = RawTypesConfig,
    TPluginConfig extends ParsedTypesConfig = ParsedTypesConfig
> extends BaseVisitor<TRawConfig, TPluginConfig> {}

constructor

constructor(
    _schema: GraphQLSchema,
    rawConfig: RawTypesConfig,
    additionalConfig: ParsedTypesConfig,
    defaultScalars?: NormalizedScalarsMap
);

property directiveArgumentAndInputFieldMappingsDefinition

readonly directiveArgumentAndInputFieldMappingsDefinition: string;

property scalarsDefinition

readonly scalarsDefinition: string;

method appendInterfacesAndFieldsToBlock

appendInterfacesAndFieldsToBlock: (
    block: DeclarationBlock,
    interfaces: string[],
    fields: string[]
) => void;

method buildArgumentsBlock

protected buildArgumentsBlock: (
    node: InterfaceTypeDefinitionNode | ObjectTypeDefinitionNode
) => string;

method buildEnumValuesBlock

protected buildEnumValuesBlock: (
    typeName: string,
    values: ReadonlyArray<EnumValueDefinitionNode>
) => string;

method DirectiveDefinition

DirectiveDefinition: (_node: DirectiveDefinitionNode) => string;

method EnumTypeDefinition

EnumTypeDefinition: (node: EnumTypeDefinitionNode) => string;

method FieldDefinition

FieldDefinition: (node: FieldDefinitionNode) => string;

method getArgumentsObjectDeclarationBlock

getArgumentsObjectDeclarationBlock: (
    node: InterfaceTypeDefinitionNode | ObjectTypeDefinitionNode,
    name: string,
    field: FieldDefinitionNode
) => DeclarationBlock;

method getArgumentsObjectTypeDefinition

getArgumentsObjectTypeDefinition: (
    node: InterfaceTypeDefinitionNode | ObjectTypeDefinitionNode,
    name: string,
    field: FieldDefinitionNode
) => string;

method getDeprecationReason

protected getDeprecationReason: (directive: DirectiveNode) => string | void;

method getDirectiveArgumentAndInputFieldMappingsImports

getDirectiveArgumentAndInputFieldMappingsImports: () => string[];

method getEntireFieldWrapperValue

getEntireFieldWrapperValue: () => string;

method getEnumsImports

getEnumsImports: () => string[];

method getExportPrefix

protected getExportPrefix: () => string;

method getFieldWrapperValue

getFieldWrapperValue: () => string;

method getInputObjectDeclarationBlock

getInputObjectDeclarationBlock: (
    node: InputObjectTypeDefinitionNode
) => DeclarationBlock;

method getInterfaceTypeDeclarationBlock

getInterfaceTypeDeclarationBlock: (
    node: InterfaceTypeDefinitionNode,
    _originalNode: InterfaceTypeDefinitionNode
) => DeclarationBlock;

method getNodeComment

getNodeComment: (node: FieldDefinitionNode | EnumValueDefinitionNode) => string;

method getObjectTypeDeclarationBlock

getObjectTypeDeclarationBlock: (
    node: ObjectTypeDefinitionNode,
    originalNode: ObjectTypeDefinitionNode
) => DeclarationBlock;

method getScalarsImports

getScalarsImports: () => string[];

method handleEnumValueMapper

protected handleEnumValueMapper: (
    typeIdentifier: string,
    importIdentifier: string | null,
    sourceIdentifier: string | null,
    sourceFile: string | null
) => string[];

method InputObjectTypeDefinition

InputObjectTypeDefinition: (node: InputObjectTypeDefinitionNode) => string;

method InputValueDefinition

InputValueDefinition: (node: InputValueDefinitionNode) => string;

method InterfaceTypeDefinition

InterfaceTypeDefinition: (
    node: InterfaceTypeDefinitionNode,
    key: number | string,
    parent: any
) => string;

method ListType

ListType: (
    node: ListTypeNode,
    key: any,
    parent: any,
    path: any,
    ancestors: any
) => string;

method makeValidEnumIdentifier

protected makeValidEnumIdentifier: (identifier: string) => string;

method mergeAllFields

protected mergeAllFields: (
    allFields: string[],
    _hasInterfaces: boolean
) => string;

method mergeInterfaces

protected mergeInterfaces: (
    interfaces: string[],
    hasOtherFields: boolean
) => string;

method Name

Name: (node: NameNode) => string;

method NamedType

NamedType: (
    node: NamedTypeNode,
    key: any,
    parent: any,
    path: any,
    ancestors: any
) => string;

method NonNullType

NonNullType: (node: NonNullTypeNode) => string;

method ObjectTypeDefinition

ObjectTypeDefinition: (
    node: ObjectTypeDefinitionNode,
    key: number | string,
    parent: any
) => string;

method ScalarTypeDefinition

ScalarTypeDefinition: (_node: ScalarTypeDefinitionNode) => string;

method SchemaDefinition

SchemaDefinition: () => any;

method setArgumentsTransformer

setArgumentsTransformer: (
    argumentsTransfomer: OperationVariablesToObject
) => void;

method setDeclarationBlockConfig

setDeclarationBlockConfig: (config: DeclarationBlockConfig) => void;

method StringValue

StringValue: (node: StringValueNode) => string;

method UnionTypeDefinition

UnionTypeDefinition: (
    node: UnionTypeDefinitionNode,
    key: string | number | undefined,
    parent: any
) => string;

method wrapWithListType

protected wrapWithListType: (str: string) => string;

class BaseVisitor

class BaseVisitor<
    TRawConfig extends RawConfig = RawConfig,
    TPluginConfig extends ParsedConfig = ParsedConfig
> {}

constructor

constructor(rawConfig: RawConfig, additionalConfig: Partial<TPluginConfig>);

property config

readonly config: ParsedConfig;

property scalars

readonly scalars: NormalizedScalarsMap;

method convertName

convertName: (
    node: ASTNode | string,
    options?: BaseVisitorConvertOptions & ConvertOptions
) => string;

method getFragmentName

getFragmentName: (node: FragmentDefinitionNode | string) => string;

method getFragmentSuffix

getFragmentSuffix: (node: FragmentDefinitionNode | string) => string;

method getFragmentVariableName

getFragmentVariableName: (node: FragmentDefinitionNode | string) => string;

method getOperationSuffix

getOperationSuffix: (
    node: FragmentDefinitionNode | OperationDefinitionNode | string,
    operationType: string
) => string;

method getPunctuation

protected getPunctuation: (_declarationKind: DeclarationKind) => string;

method getVisitorKindContextFromAncestors

protected getVisitorKindContextFromAncestors: (ancestors: ASTNode[]) => string[];

class ClientSideBaseVisitor

class ClientSideBaseVisitor<
    TRawConfig extends RawClientSideBasePluginConfig = RawClientSideBasePluginConfig,
    TPluginConfig extends ClientSideBasePluginConfig = ClientSideBasePluginConfig
> extends BaseVisitor<TRawConfig, TPluginConfig> {}

constructor

constructor(
    _schema: GraphQLSchema,
    _fragments: {
        name: string;
        onType: string;
        node: FragmentDefinitionNode;
        isExternal: boolean;
        importFrom?: string;
    }[],
    rawConfig: RawClientSideBasePluginConfig,
    additionalConfig: Partial<TPluginConfig>,
    documents?: Types.DocumentFile[]
);

property fragments

readonly fragments: string;

method buildOperation

protected buildOperation: (
    _node: OperationDefinitionNode,
    _documentVariableName: string,
    _operationType: string,
    _operationResultType: string,
    _operationVariablesTypes: string,
    _hasRequiredVariables: boolean
) => string;

method checkVariablesRequirements

protected checkVariablesRequirements: (node: OperationDefinitionNode) => boolean;

Checks if the specific operation has variables that are non-null (required), and also doesn't have default. This is useful for deciding of variables should be optional or not.
Parameter node

method getDocumentNodeSignature

protected getDocumentNodeSignature: (
    _resultType: string,
    _variablesTypes: string,
    _node: FragmentDefinitionNode | OperationDefinitionNode
) => string;

method getImports

getImports: (options?: { excludeFragments?: boolean }) => string[];

method getOperationVariableName

getOperationVariableName: (node: OperationDefinitionNode) => string;

method OperationDefinition

OperationDefinition: (node: OperationDefinitionNode) => string;

class DeclarationBlock

class DeclarationBlock {}

constructor

constructor(_config: DeclarationBlockConfig);

property string

readonly string: string;

method asKind

asKind: (kind: string) => DeclarationBlock;

method export

export: (exp?: boolean) => DeclarationBlock;

method withBlock

withBlock: (block: string) => DeclarationBlock;

method withComment

withComment: (
    comment: string | StringValueNode | null,
    disabled?: boolean
) => DeclarationBlock;

method withContent

withContent: (content: string) => DeclarationBlock;

method withDecorator

withDecorator: (decorator: string) => DeclarationBlock;

method withMethodCall

withMethodCall: (
    methodName: string,
    ignoreBlockWrapper?: boolean
) => DeclarationBlock;

method withName

withName: (
    name: string | NameNode,
    generics?: string | null
) => DeclarationBlock;

class OperationVariablesToObject

class OperationVariablesToObject {}

constructor

constructor(
    _scalars: NormalizedScalarsMap,
    _convertName: ConvertNameFn<BaseVisitorConvertOptions>,
    _namespacedImportName?: string,
    _enumNames?: string[],
    _enumPrefix?: boolean,
    _enumValues?: ParsedEnumValuesMap,
    _applyCoercion?: boolean,
    _directiveArgumentAndInputFieldMappings?: ParsedDirectiveArgumentAndInputFieldMappings
);

method formatFieldString

protected formatFieldString: (
    fieldName: string,
    isNonNullType: boolean,
    _hasDefaultValue: boolean
) => string;

method formatTypeString

protected formatTypeString: (
    fieldType: string,
    isNonNullType: boolean,
    hasDefaultValue: boolean
) => string;

method getDirectiveMapping

protected getDirectiveMapping: (name: string) => string;

method getDirectiveOverrideType

protected getDirectiveOverrideType: (
    directives: ReadonlyArray<DirectiveNode>
) => string | null;

method getName

getName: <TDefinitionType extends InterfaceOrVariable>(
    node: TDefinitionType
) => string;

method getPunctuation

protected getPunctuation: () => string;

method getScalar

protected getScalar: (name: string) => string;

method transform

transform: <TDefinitionType extends InterfaceOrVariable>(
    variablesNode: ReadonlyArray<TDefinitionType>
) => string;

method transformVariable

protected transformVariable: <TDefinitionType extends InterfaceOrVariable>(
    variable: TDefinitionType
) => string;

method wrapAstTypeWithModifiers

wrapAstTypeWithModifiers: (
    _baseType: string,
    _typeNode: TypeNode,
    _applyCoercion?: Boolean
) => string;

class PreResolveTypesProcessor

class PreResolveTypesProcessor extends BaseSelectionSetProcessor<SelectionSetProcessorConfig> {}

method transformAliasesPrimitiveFields

transformAliasesPrimitiveFields: (
    schemaType: GraphQLObjectType | GraphQLInterfaceType,
    fields: PrimitiveAliasedFields[]
) => (string | NameAndType)[];

method transformLinkFields

transformLinkFields: (fields: LinkField[]) => (string | NameAndType)[];

method transformPrimitiveFields

transformPrimitiveFields: (
    schemaType: GraphQLObjectType | GraphQLInterfaceType,
    fields: PrimitiveField[]
) => (string | NameAndType)[];

method transformTypenameField

transformTypenameField: (type: string, name: string) => (string | NameAndType)[];

class SelectionSetToObject

class SelectionSetToObject<
    Config extends ParsedDocumentsConfig = ParsedDocumentsConfig
> {}

constructor

constructor(
    _processor: BaseSelectionSetProcessor<any>,
    _scalars: NormalizedScalarsMap,
    _schema: GraphQLSchema,
    _convertName: ConvertNameFn<BaseVisitorConvertOptions>,
    _getFragmentSuffix: GetFragmentSuffixFn,
    _loadedFragments: {
        name: string;
        onType: string;
        node: FragmentDefinitionNode;
        isExternal: boolean;
        importFrom?: string;
    }[],
    _config: ParsedDocumentsConfig,
    _parentSchemaType?: GraphQLNamedType,
    _selectionSet?: SelectionSetNode
);

method buildFragmentSpreadsUsage

protected buildFragmentSpreadsUsage: (
    spreads: FragmentSpreadNode[]
) => Record<string, FragmentSpreadUsage[]>;

method buildFragmentTypeName

protected buildFragmentTypeName: (
    name: string,
    suffix: string,
    typeName?: string
) => string;

method buildSelectionSet

protected buildSelectionSet: (
    parentSchemaType: GraphQLObjectType,
    selectionNodes: Array<SelectionNode | FragmentSpreadUsage | DirectiveNode>
) => { typeInfo: { name: string; type: string }; fields: string[] };

method buildTypeNameField

protected buildTypeNameField: (
    type: GraphQLObjectType,
    nonOptionalTypename?: boolean,
    addTypename?: boolean,
    queriedForTypename?: boolean,
    skipTypeNameForRoot?: boolean
) => { name: string; type: string };

method createNext

createNext: (
    parentSchemaType: GraphQLNamedType,
    selectionSet: SelectionSetNode
) => SelectionSetToObject;

method flattenSelectionSet

protected flattenSelectionSet: (
    selections: ReadonlyArray<SelectionNode>
) => Map<string, Array<SelectionNode | FragmentSpreadUsage>>;

method getEmptyObjectType

protected getEmptyObjectType: () => string;

method getUnknownType

protected getUnknownType: () => string;

method selectionSetStringFromFields

protected selectionSetStringFromFields: (
    fields: (string | NameAndType)[]
) => string | null;

method transformFragmentSelectionSetToTypes

transformFragmentSelectionSetToTypes: (
    fragmentName: string,
    fragmentSuffix: string,
    declarationBlockConfig: any
) => string;

method transformSelectionSet

transformSelectionSet: () => string;

Interfaces

interface AvoidOptionalsConfig

interface AvoidOptionalsConfig {}

property defaultValue

defaultValue?: boolean;

property field

field?: boolean;

property inputValue

inputValue?: boolean;

property object

object?: boolean;

property resolvers

resolvers?: boolean;

interface BaseVisitorConvertOptions

interface BaseVisitorConvertOptions {}

property useTypesPrefix

useTypesPrefix?: boolean;

property useTypesSuffix

useTypesSuffix?: boolean;

interface ClientSideBasePluginConfig

interface ClientSideBasePluginConfig extends ParsedConfig {}

property dedupeOperationSuffix

dedupeOperationSuffix: boolean;

property documentMode

documentMode?: DocumentMode;

property documentNodeImport

documentNodeImport: string;

property documentVariablePrefix

documentVariablePrefix: string;

property documentVariableSuffix

documentVariableSuffix: string;

property experimentalFragmentVariables

experimentalFragmentVariables?: boolean;

property fragmentVariablePrefix

fragmentVariablePrefix: string;

property fragmentVariableSuffix

fragmentVariableSuffix: string;

property globalNamespace

globalNamespace?: boolean;

property gqlImport

gqlImport: string;

property importDocumentNodeExternallyFrom

importDocumentNodeExternallyFrom?: 'near-operation-file' | string;

property importOperationTypesFrom

importOperationTypesFrom?: string;

property noExport

noExport: boolean;

property omitOperationSuffix

omitOperationSuffix: boolean;

property operationResultSuffix

operationResultSuffix: string;

property optimizeDocumentNode

optimizeDocumentNode: boolean;

property pureMagicComment

pureMagicComment?: boolean;

interface ConvertOptions

interface ConvertOptions {}

property prefix

prefix?: string;

property suffix

suffix?: string;

property transformUnderscore

transformUnderscore?: boolean;

interface DeclarationBlockConfig

interface DeclarationBlockConfig {}

property blockTransformer

blockTransformer?: (block: string) => string;

property blockWrapper

blockWrapper?: string;

property enumNameValueSeparator

enumNameValueSeparator?: string;

property ignoreExport

ignoreExport?: boolean;

interface DeclarationKindConfig

interface DeclarationKindConfig {}

property arguments

arguments?: DeclarationKind;

property directive

directive?: DeclarationKind;

property input

input?: DeclarationKind;

property interface

interface?: DeclarationKind;

property scalar

scalar?: DeclarationKind;

property type

type?: DeclarationKind;

interface ExternalParsedMapper

interface ExternalParsedMapper {}

property default

default: boolean;

property import

import: string;

property isExternal

isExternal: true;

property source

source: string;

property type

type: string;

interface InterfaceOrVariable

interface InterfaceOrVariable {}

property defaultValue

defaultValue?: ValueNode;

property directives

directives?: ReadonlyArray<DirectiveNode>;

property name

name?: NameNode;

property type

type: TypeNode;

property variable

variable?: VariableNode;

interface InternalParsedMapper

interface InternalParsedMapper {}

property isExternal

isExternal: false;

property type

type: string;

interface NamingConventionMap

interface NamingConventionMap {}

false

property enumValues

enumValues?: 'keep' | NamingConventionResolvePath | NamingConventionFn;

property transformUnderscore

transformUnderscore?: boolean;

property typeNames

typeNames?: 'keep' | NamingConventionResolvePath | NamingConventionFn;

interface ParsedConfig

interface ParsedConfig {}

property addTypename

addTypename: boolean;

property allowEnumStringTypes

allowEnumStringTypes: boolean;

property convert

convert: ConvertFn;

property dedupeFragments

dedupeFragments: boolean;

property externalFragments

externalFragments: LoadedFragment[];

property fragmentImports

fragmentImports: ImportDeclaration<FragmentImport>[];

property immutableTypes

immutableTypes: boolean;

property inlineFragmentTypes

inlineFragmentTypes: InlineFragmentTypeOptions;

property nonOptionalTypename

nonOptionalTypename: boolean;

property scalars

scalars: ParsedScalarsMap;

property typesPrefix

typesPrefix: string;

property typesSuffix

typesSuffix: string;

property useTypeImports

useTypeImports: boolean;

interface ParsedDocumentsConfig

interface ParsedDocumentsConfig extends ParsedTypesConfig {}

property addTypename

addTypename: boolean;

property dedupeOperationSuffix

dedupeOperationSuffix: boolean;

property experimentalFragmentVariables

experimentalFragmentVariables: boolean;

property exportFragmentSpreadSubTypes

exportFragmentSpreadSubTypes: boolean;

property globalNamespace

globalNamespace: boolean;

property mergeFragmentTypes

mergeFragmentTypes: boolean;

property namespacedImportName

namespacedImportName: string | null;

property omitOperationSuffix

omitOperationSuffix: boolean;

property operationResultSuffix

operationResultSuffix: string;

property preResolveTypes

preResolveTypes: boolean;

property skipTypeNameForRoot

skipTypeNameForRoot: boolean;

interface ParsedImport

interface ParsedImport {}

property moduleName

moduleName: string | null;

property propName

propName: string;

interface ParsedResolversConfig

interface ParsedResolversConfig extends ParsedConfig {}

property addUnderscoreToArgsType

addUnderscoreToArgsType: boolean;

property allResolversTypeName

allResolversTypeName: string;

property avoidOptionals

avoidOptionals: AvoidOptionalsConfig;

property contextType

contextType: ParsedMapper;

property defaultMapper

defaultMapper: ParsedMapper | null;

property directiveContextTypes

directiveContextTypes: Array<string>;

property directiveResolverMappings

directiveResolverMappings: Record<string, string>;

property enumPrefix

enumPrefix: boolean;

property enumValues

enumValues: ParsedEnumValuesMap;

property federation

federation: boolean;

property fieldContextTypes

fieldContextTypes: Array<string>;

property immutableTypes

immutableTypes: boolean;

property internalResolversPrefix

internalResolversPrefix: string;

property mappers

mappers: {
    [typeName: string]: ParsedMapper;
};

property namespacedImportName

namespacedImportName: string;

property onlyResolveTypeForInterfaces

onlyResolveTypeForInterfaces: boolean;

property optionalResolveType

optionalResolveType: boolean;

property resolverTypeSuffix

resolverTypeSuffix: string;

property resolverTypeWrapperSignature

resolverTypeWrapperSignature: string;

property rootValueType

rootValueType: ParsedMapper;

interface ParsedTypesConfig

interface ParsedTypesConfig extends ParsedConfig {}

property addUnderscoreToArgsType

addUnderscoreToArgsType: boolean;

property declarationKind

declarationKind: DeclarationKindConfig;

property directiveArgumentAndInputFieldMappings

directiveArgumentAndInputFieldMappings: ParsedDirectiveArgumentAndInputFieldMappings;

property entireFieldWrapperValue

entireFieldWrapperValue: string;

property enumPrefix

enumPrefix: boolean;

property enumValues

enumValues: ParsedEnumValuesMap;

property fieldWrapperValue

fieldWrapperValue: string;

property ignoreEnumValuesFromSchema

ignoreEnumValuesFromSchema: boolean;

property onlyEnums

onlyEnums: boolean;

property onlyOperationTypes

onlyOperationTypes: boolean;

property wrapEntireDefinitions

wrapEntireDefinitions: boolean;

property wrapFieldDefinitions

wrapFieldDefinitions: boolean;

interface RawClientSideBasePluginConfig

interface RawClientSideBasePluginConfig extends RawConfig {}

property dedupeOperationSuffix

dedupeOperationSuffix?: boolean;

false Set this configuration to true if you wish to make sure to remove duplicate operation name suffix.

property documentMode

documentMode?: DocumentMode;

graphQLTag Declares how DocumentNode are created:
- graphQLTag: graphql-tag or other modules (check gqlImport) will be used to generate document nodes. If this is used, document nodes are generated on client side i.e. the module used to generate this will be shipped to the client - documentNode: document nodes will be generated as objects when we generate the templates. - documentNodeImportFragments: Similar to documentNode except it imports external fragments instead of embedding them. - external: document nodes are imported from an external file. To be used with importDocumentNodeExternallyFrom
Note that some plugins (like typescript-graphql-request) also supports string for this parameter.

property documentNodeImport

documentNodeImport?: string;

graphql#DocumentNode Customize from which module will DocumentNode be imported from. This is useful if you want to use modules other than graphql, e.g. @graphql-typed-document-node.

property documentVariablePrefix

documentVariablePrefix?: string;

"" Changes the GraphQL operations variables prefix.

property documentVariableSuffix

documentVariableSuffix?: string;

Document Changes the GraphQL operations variables suffix.

property experimentalFragmentVariables

experimentalFragmentVariables?: boolean;

false If set to true, it will enable support for parsing variables on fragments.

property fragmentVariablePrefix

fragmentVariablePrefix?: string;

"" Changes the GraphQL fragments variables prefix.

property fragmentVariableSuffix

fragmentVariableSuffix?: string;

FragmentDoc Changes the GraphQL fragments variables suffix.

property gqlImport

gqlImport?: string;

graphql-tag#gql Customize from which module will gql be imported from. This is useful if you want to use modules other than graphql-tag, e.g. graphql.macro.
## graphql.macro
config: gqlImport: graphql.macro#gql
## Gatsby
config: gqlImport: gatsby#graphql

property importDocumentNodeExternallyFrom

importDocumentNodeExternallyFrom?: string;

"" This config should be used if documentMode is external. This has 2 usage:
- any string: This would be the path to import document nodes from. This can be used if we want to manually create the document nodes e.g. Use graphql-tag in a separate file and export the generated document - 'near-operation-file': This is a special mode that is intended to be used with near-operation-file preset to import document nodes from those files. If these files are .graphql files, we make use of webpack loader.
config: documentMode: external importDocumentNodeExternallyFrom: path/to/document-node-file
config: documentMode: external importDocumentNodeExternallyFrom: near-operation-file

property importOperationTypesFrom

importOperationTypesFrom?: string;

"" This config is used internally by presets, but you can use it manually to tell codegen to prefix all base types that it's using. This is useful if you wish to generate base types from typescript-operations plugin into a different file, and import it from there.

property noExport

noExport?: boolean;

false Set this configuration to true if you wish to tell codegen to generate code with no export identifier.

property noGraphQLTag

noGraphQLTag?: boolean;

Deprecated. Changes the documentMode to documentNode. false

property omitOperationSuffix

omitOperationSuffix?: boolean;

false Set this configuration to true if you wish to disable auto add suffix of operation name, like Query, Mutation, Subscription, Fragment.

property operationResultSuffix

operationResultSuffix?: string;

"" Adds a suffix to generated operation result type names

property optimizeDocumentNode

optimizeDocumentNode?: boolean;

true If you are using documentNode: documentMode | documentNodeImportFragments, you can set this to true to apply document optimizations for your GraphQL document. This will remove all "loc" and "description" fields from the compiled document, and will remove all empty arrays (such as directives, arguments and variableDefinitions).

property pureMagicComment

pureMagicComment?: boolean;

false This config adds PURE magic comment to the static variables to enforce treeshaking for your bundler.

interface RawConfig

interface RawConfig {}

property allowEnumStringTypes

allowEnumStringTypes?: boolean;

property dedupeFragments

dedupeFragments?: boolean;

Removes fragment duplicates for reducing data transfer. It is done by removing sub-fragments imports from fragment definition Instead - all of them are imported to the Operation node. boolean false

property defaultScalarType

defaultScalarType?: string;

Allows you to override the type that unknown scalars will have. any
config: defaultScalarType: unknown

property externalFragments

externalFragments?: LoadedFragment[];

property fragmentImports

fragmentImports?: ImportDeclaration<FragmentImport>[];

property globalNamespace

globalNamespace?: boolean;

property inlineFragmentTypes

inlineFragmentTypes?: InlineFragmentTypeOptions;

Whether fragment types should be inlined into other operations. "inline" is the default behavior and will perform deep inlining fragment types within operation type definitions. "combine" is the previous behavior that uses fragment type references without inlining the types (and might cause issues with deeply nested fragment that uses list types).
string inline

property namingConvention

namingConvention?: NamingConvention;

change-case-all#pascalCase Allow you to override the naming convention of the output. You can either override all namings, or specify an object with specific custom naming convention per output. The format of the converter must be a valid module#method. Allowed values for specific output are: typeNames, enumValues. You can also use "keep" to keep all GraphQL names as-is. Additionally, you can set transformUnderscore to true if you want to override the default behavior, which is to preserve underscores.
Available case functions in change-case-all are camelCase, capitalCase, constantCase, dotCase, headerCase, noCase, paramCase, pascalCase, pathCase, sentenceCase, snakeCase, lowerCase, localeLowerCase, lowerCaseFirst, spongeCase, titleCase, upperCase, localeUpperCase and upperCaseFirst [See more](https://github.com/btxtiger/change-case-all)
## Override All Names
config: namingConvention: change-case-all#lowerCase
## Upper-case enum values
config: namingConvention: typeNames: change-case-all#pascalCase enumValues: change-case-all#upperCase
## Keep names as is
config: namingConvention: keep
## Remove Underscores
config: namingConvention: typeNames: change-case-all#pascalCase transformUnderscore: true

property nonOptionalTypename

nonOptionalTypename?: boolean;

false Automatically adds __typename field to the generated types, even when they are not specified in the selection set, and makes it non-optional
config: nonOptionalTypename: true

property scalars

scalars?: ScalarsMap;

Extends or overrides the built-in scalars and custom GraphQL scalars to a custom type.
config: scalars: DateTime: Date JSON: "{ [key: string]: any }"

property skipTypename

skipTypename?: boolean;

false Does not add __typename to the generated types, unless it was specified in the selection set.
config: skipTypename: true

property strictScalars

strictScalars?: boolean;

Makes scalars strict.
If scalars are found in the schema that are not defined in scalars an error will be thrown during codegen. false
config: strictScalars: true

property typesPrefix

typesPrefix?: string;

"" Prefixes all the generated types.
config: typesPrefix: I

property typesSuffix

typesSuffix?: string;

"" Suffixes all the generated types.
config: typesSuffix: I

property useTypeImports

useTypeImports?: boolean;

useTypeImports boolean false Will use import type {} rather than import {} when importing only types. This gives compatibility with TypeScript's "importsNotUsedAsValues": "error" option
Example 1
config: useTypeImports: true

interface RawDocumentsConfig

interface RawDocumentsConfig extends RawTypesConfig {}

property dedupeOperationSuffix

dedupeOperationSuffix?: boolean;

false Set this configuration to true if you wish to make sure to remove duplicate operation name suffix.

property experimentalFragmentVariables

experimentalFragmentVariables?: boolean;

false If set to true, it will enable support for parsing variables on fragments.

property exportFragmentSpreadSubTypes

exportFragmentSpreadSubTypes?: boolean;

false If set to true, it will export the sub-types created in order to make it easier to access fields declared under fragment spread.

property globalNamespace

globalNamespace?: boolean;

false Puts all generated code under global namespace. Useful for Stencil integration.
plugins config: globalNamespace: true

property mergeFragmentTypes

mergeFragmentTypes?: boolean;

false If set to true, merge equal fragment interfaces.

property namespacedImportName

namespacedImportName?: string;

property omitOperationSuffix

omitOperationSuffix?: boolean;

false Set this configuration to true if you wish to disable auto add suffix of operation name, like Query, Mutation, Subscription, Fragment.

property operationResultSuffix

operationResultSuffix?: string;

"" Adds a suffix to generated operation result type names

property preResolveTypes

preResolveTypes?: boolean;

true Uses primitive types where possible. Set to false in order to use Pick and take use the types generated by typescript plugin.
plugins config: preResolveTypes: false

property skipTypeNameForRoot

skipTypeNameForRoot?: boolean;

false Avoid adding __typename for root types. This is ignored when a selection explicitly specifies __typename.
plugins config: skipTypeNameForRoot: true

interface RawResolversConfig

interface RawResolversConfig extends RawConfig {}

property addUnderscoreToArgsType

addUnderscoreToArgsType?: boolean;

Adds _ to generated Args types in order to avoid duplicate identifiers.
config: addUnderscoreToArgsType: true

property allResolversTypeName

allResolversTypeName?: string;

Resolvers The type name to use when exporting all resolvers signature as unified type.

property avoidOptionals

avoidOptionals?: boolean | AvoidOptionalsConfig;

This will cause the generator to avoid using optionals (?), so all field resolvers must be implemented in order to avoid compilation errors. false

## Override all definition types

generates:
  path/to/file.ts:
    plugins:
      - typescript
      - typescript-resolvers
    config:
      avoidOptionals: true

## Override only specific definition types

generates:
  path/to/file.ts:
    plugins:
      - typescript
    config:
      avoidOptionals:
        field: true
        inputValue: true
        object: true
        defaultValue: true

property contextType

contextType?: string;

Use this configuration to set a custom type for your context, and it will affect all the resolvers, without the need to override it using generics each time. If you wish to use an external type and import it from another file, you can use add plugin and add the required import statement, or you can use a module#type syntax.
## Custom Context Type
plugins config: contextType: MyContext
## Custom Context Type
plugins config: contextType: ./my-types#MyContext

property defaultMapper

defaultMapper?: string;

Allow you to set the default mapper when it's not being override by mappers or generics. You can specify a type name, or specify a string in module#type or module#namespace#type format. The default value of mappers is the TypeScript type generated by typescript package.
## Replace with any
plugins config: defaultMapper: any
## Custom Base Object
plugins config: defaultMapper: ./my-file#BaseObject
## Wrap default types with Partial
You can also specify a custom wrapper for the original type, without overriding the original generated types, use {T} to specify the identifier. (for flow, use $Shape<{T}>)
plugins config: defaultMapper: Partial<{T}>
## Allow deep partial with utility-types
plugins plugins: - 'typescript' - 'typescript-resolvers' - add: content: "import { DeepPartial } from 'utility-types';" config: defaultMapper: DeepPartial<{T}>

property directiveContextTypes

directiveContextTypes?: Array<string>;

Use this configuration to set a custom type for the rootValue, and it will affect resolvers of all root types (Query, Mutation and Subscription), without the need to override it using generics each time. If you wish to use an external type and import it from another file, you can use add plugin and add the required import statement, or you can use both module#type or module#namespace#type syntax.
## Custom RootValue Type
plugins config: rootValueType: MyRootValue
## Custom RootValue Type
plugins config: rootValueType: ./my-types#MyRootValue

property directiveResolverMappings

directiveResolverMappings?: Record<string, string>;

property enumPrefix

enumPrefix?: boolean;

true Allow you to disable prefixing for generated enums, works in combination with typesPrefix.
## Disable enum prefixes
config: typesPrefix: I enumPrefix: false

property enumValues

enumValues?: EnumValuesMap;

Overrides the default value of enum values declared in your GraphQL schema, supported in this plugin because of the need for integration with typescript package. See documentation under typescript plugin for more information and examples.

property federation

federation?: boolean;

false Supports Apollo Federation

property fieldContextTypes

fieldContextTypes?: Array<string>;

Use this to set a custom type for a specific field context. It will only affect the targeted resolvers. You can either use Field.Path#ContextTypeName or Field.Path#ExternalFileName#ContextTypeName
## Custom Field Context Types
plugins config: fieldContextTypes: - MyType.foo#CustomContextType - MyType.bar#./my-file#ContextTypeOne

property immutableTypes

immutableTypes?: boolean;

false Generates immutable types by adding readonly to properties and uses ReadonlyArray.

property internalResolversPrefix

internalResolversPrefix?: string;

string '__' Defines the prefix value used for __resolveType and __isTypeOf resolvers. If you are using mercurius-js, please set this field to empty string for better compatibility.

property mappers

mappers?: {
    [typeName: string]: string;
};

Replaces a GraphQL type usage with a custom type, allowing you to return custom object from your resolvers. You can use both module#type and module#namespace#type syntax.
## Custom Context Type
plugins config: mappers: User: ./my-models#UserDbObject Book: ./my-models#Collections#Book

property mapperTypeSuffix

mapperTypeSuffix?: string;

Adds a suffix to the imported names to prevent name clashes.
plugins config: mapperTypeSuffix: Model

property namespacedImportName

namespacedImportName?: string;

'' Prefixes all GraphQL related generated types with that value, as namespaces import. You can use this feature to allow separation of plugins to different files.

property onlyResolveTypeForInterfaces

onlyResolveTypeForInterfaces?: boolean;

boolean false Turning this flag to true will generate resolver signature that has only resolveType for interfaces, forcing developers to write inherited type resolvers in the type itself.

property optionalResolveType

optionalResolveType?: boolean;

false Sets the __resolveType field as optional field.

property resolverTypeSuffix

resolverTypeSuffix?: string;

Resolvers Suffix we add to each generated type resolver.

property resolverTypeWrapperSignature

resolverTypeWrapperSignature?: string;

Promise | T Allow you to override resolverTypeWrapper definition.

property rootValueType

rootValueType?: string;

Use this to set a custom type for a specific field context decorated by a directive. It will only affect the targeted resolvers. You can either use Field.Path#ContextTypeName or Field.Path#ExternalFileName#ContextTypeName
ContextTypeName should by a generic Type that take the context or field context type as only type parameter.
## Directive Context Extender
plugins config: directiveContextTypes: - myCustomDirectiveName#./my-file#CustomContextExtender

property showUnusedMappers

showUnusedMappers?: boolean;

Warns about unused mappers. true

generates:
  path/to/file.ts:
    plugins:
      - typescript
      - typescript-resolvers
    config:
      showUnusedMappers: true

interface RawTypesConfig

interface RawTypesConfig extends RawConfig {}

property addUnderscoreToArgsType

addUnderscoreToArgsType?: boolean;

Adds _ to generated Args types in order to avoid duplicate identifiers.
## With Custom Values
config: addUnderscoreToArgsType: true

property declarationKind

declarationKind?: DeclarationKind | DeclarationKindConfig;

Overrides the default output for various GraphQL elements.

## Override all declarations

  config:
    declarationKind: 'interface'

## Override only specific declarations

  config:
    declarationKind:
      type: 'interface'
      input: 'interface'

property directiveArgumentAndInputFieldMappings

directiveArgumentAndInputFieldMappings?: DirectiveArgumentAndInputFieldMappings;

Replaces a GraphQL scalar with a custom type based on the applied directive on an argument or input field.
You can use both module#type and module#namespace#type syntax. Will NOT work with introspected schemas since directives are not exported. Only works with directives on ARGUMENT_DEFINITION or INPUT_FIELD_DEFINITION.
**WARNING:** Using this option does only change the type definitions.
For actually ensuring that a type is correct at runtime you will have to use schema transforms (e.g. with [@graphql-tools/utils mapSchema](https://graphql-tools.com/docs/schema-directives)) that apply those rules! Otherwise, you might end up with a runtime type mismatch which could cause unnoticed bugs or runtime errors.
Please use this configuration option with care!
## Custom Context Type
plugins: config: directiveArgumentAndInputFieldMappings: AsNumber: number AsComplex: ./my-models#Complex

property directiveArgumentAndInputFieldMappingTypeSuffix

directiveArgumentAndInputFieldMappingTypeSuffix?: string;

Adds a suffix to the imported names to prevent name clashes.

plugins:
  config:
    directiveArgumentAndInputFieldMappingTypeSuffix: Model

property entireFieldWrapperValue

entireFieldWrapperValue?: string;

entireFieldWrapperValue string Allow to override the type value of EntireFieldWrapper. This wrapper applies outside of Array and Maybe unlike fieldWrapperValue, that will wrap the inner type. T | Promise | (() => T | Promise)
Example 1
Only allow values
generates: path/to/file.ts: plugins: - typescript config: entireFieldWrapperValue: T

property enumPrefix

enumPrefix?: boolean;

true Allow you to disable prefixing for generated enums, works in combination with typesPrefix.
## Disable enum prefixes
config: typesPrefix: I enumPrefix: false

property enumValues

enumValues?: EnumValuesMap;

Overrides the default value of enum values declared in your GraphQL schema. You can also map the entire enum to an external type by providing a string that of module#type.
## With Custom Values
config: enumValues: MyEnum: A: 'foo'
## With External Enum
config: enumValues: MyEnum: ./my-file#MyCustomEnum
## Import All Enums from a file
config: enumValues: ./my-file

property fieldWrapperValue

fieldWrapperValue?: string;

Allow you to add wrapper for field type, use T as the generic value. Make sure to set wrapFieldDefinitions to true in order to make this flag work. T

## Allow Promise

generates:
  path/to/file.ts:
    plugins:
      - typescript
    config:
      wrapFieldDefinitions: true
      fieldWrapperValue: T | Promise<T>

property ignoreEnumValuesFromSchema

ignoreEnumValuesFromSchema?: boolean;

This will cause the generator to ignore enum values defined in GraphQLSchema false

## Ignore enum values from schema

generates:
  path/to/file.ts:
    plugins:
      - typescript
    config:
      ignoreEnumValuesFromSchema: true

property onlyEnums

onlyEnums?: boolean;

This will cause the generator to emit types for enums only false

## Override all definition types

generates:
  path/to/file.ts:
    plugins:
      - typescript
    config:
      onlyEnums: true

property onlyOperationTypes

onlyOperationTypes?: boolean;

This will cause the generator to emit types for operations only (basically only enums and scalars) false
## Override all definition types
generates: path/to/file.ts: plugins: - typescript config: onlyOperationTypes: true

property wrapEntireFieldDefinitions

wrapEntireFieldDefinitions?: boolean;

wrapEntireFieldDefinitions boolean Set to true in order to wrap field definitions with EntireFieldWrapper. This is useful to allow return types such as Promises and functions for fields. Differs from wrapFieldDefinitions in that this wraps the entire field definition if i.e. the field is an Array, while wrapFieldDefinitions will wrap every single value inside the array. true
Example 1
Enable wrapping entire fields
generates: path/to/file.ts: plugins: - typescript config: wrapEntireFieldDefinitions: false

property wrapFieldDefinitions

wrapFieldDefinitions?: boolean;

Set to true in order to wrap field definitions with FieldWrapper. This is useful to allow return types such as Promises and functions. false
## Enable wrapping fields
generates: path/to/file.ts: plugins: - typescript config: wrapFieldDefinitions: true

Enums

enum DocumentMode

enum DocumentMode {
    graphQLTag = 'graphQLTag',
    documentNode = 'documentNode',
    documentNodeImportFragments = 'documentNodeImportFragments',
    external = 'external',
    string = 'string',
}

member documentNode

documentNode = 'documentNode'

member documentNodeImportFragments

documentNodeImportFragments = 'documentNodeImportFragments'

member external

external = 'external'

member graphQLTag

graphQLTag = 'graphQLTag'

member string

string = 'string'

Type Aliases

type ConvertFn

type ConvertFn<T = {}> = (
    node: ASTNode | string,
    options?: ConvertOptions & T
) => string;

type ConvertNameFn

type ConvertNameFn<T = {}> = ConvertFn<T>;

type DeclarationKind

type DeclarationKind = 'type' | 'interface' | 'class' | 'abstract class';

type DirectiveArgumentAndInputFieldMappings

type DirectiveArgumentAndInputFieldMappings = {
    [name: string]: string;
};

A map between the GraphQL directive name and the identifier that should be used

type EnumValuesMap

type EnumValuesMap<AdditionalProps = {}> =
    | string
    | {
          [enumName: string]:
              | string
              | ({
                    [key: string]: string | number;
                } & AdditionalProps);
      };

A raw configuration for enumValues map - can be represented with a single string value for a file path, a map between enum name and a file path, or a map between enum name and an object with explicit enum values.

type FragmentImport

type FragmentImport = {
    name: string;
    kind: 'type' | 'document';
};

type GetFragmentSuffixFn

type GetFragmentSuffixFn = (node: FragmentDefinitionNode | string) => string;

type GroupedMappers

type GroupedMappers = Record<
    string,
    {
        identifier: string;
        asDefault?: boolean;
    }[]
>;

type ImportDeclaration

type ImportDeclaration<T = string> = {
    outputPath: string;
    importSource: ImportSource<T>;
    baseOutputDir: string;
    baseDir: string;
    typesImport: boolean;
};

type ImportSource

type ImportSource<T = string> = {
    /**
     * Source path, relative to the `baseOutputDir`
     */
    path: string;
    /**
     * Namespace to import source as
     */
    namespace?: string;
    /**
     * Entity names to import
     */
    identifiers?: T[];
};

type InlineFragmentTypeOptions

type InlineFragmentTypeOptions = 'inline' | 'combine' | 'mask';

type LinkField

type LinkField = {
    alias: string;
    name: string;
    type: string;
    selectionSet: string;
};

type LoadedFragment

type LoadedFragment<AdditionalFields = {}> = {
    name: string;
    onType: string;
    node: FragmentDefinitionNode;
    isExternal: boolean;
    importFrom?: string | null;
} & AdditionalFields;

type NameAndType

type NameAndType = {
    name: string;
    type: string;
};

type NamingConvention

type NamingConvention = string | NamingConventionFn | NamingConventionMap;

type NamingConventionFn

type NamingConventionFn = (str: string) => string;

type NamingConventionResolvePath

type NamingConventionResolvePath = string;

type NormalizedScalarsMap

type NormalizedScalarsMap = {
    [name: string]: string;
};

A normalized map between GraphQL scalar name and the identifier name

type ParsedDirectiveArgumentAndInputFieldMappings

type ParsedDirectiveArgumentAndInputFieldMappings = {
    [name: string]: ParsedMapper;
};

Parsed directives map - a mapping between GraphQL directive name and the parsed mapper object, including all required information for generating code for that mapping.

type ParsedEnumValuesMap

type ParsedEnumValuesMap = {
    [enumName: string]: {
        mappedValues?: {
            [valueName: string]: string | number;
        };
        typeIdentifier: string;
        sourceIdentifier?: string;
        sourceFile?: string;
        importIdentifier?: string;
        isDefault?: boolean;
    };
};

type ParsedMapper

type ParsedMapper = InternalParsedMapper | ExternalParsedMapper;

type ParsedScalarsMap

type ParsedScalarsMap = {
    [name: string]: ParsedMapper;
};

Parsed scalars map - a mapping between GraphQL scalar name and the parsed mapper object, including all required information for generting code for that mapping.

type PrimitiveAliasedFields

type PrimitiveAliasedFields = {
    alias: string;
    fieldName: string;
};

type PrimitiveField

type PrimitiveField = {
    isConditional: boolean;
    fieldName: string;
};

type ProcessResult

type ProcessResult = null | Array<NameAndType | string>;

type ResolverParentTypes

type ResolverParentTypes = {
    [gqlType: string]: string;
};

type ResolverTypes

type ResolverTypes = {
    [gqlType: string]: string;
};

type ScalarsMap

type ScalarsMap =
    | string
    | {
          [name: string]: string;
      };

Scalars map or a string, a map between the GraphQL scalar name and the identifier that should be used

type SelectionSetProcessorConfig

type SelectionSetProcessorConfig = {
    namespacedImportName: string | null;
    convertName: ConvertNameFn<any>;
    enumPrefix: boolean | null;
    scalars: ScalarsMap;
    formatNamedField(
        name: string,
        type?: GraphQLOutputType | GraphQLNamedType | null,
        isConditional?: boolean
    ): string;
    wrapTypeWithModifiers(
        baseType: string,
        type: GraphQLOutputType | GraphQLNamedType
    ): string;
    avoidOptionals?: AvoidOptionalsConfig;
};

Dependencies (10)

Dev Dependencies (0)

No dev dependencies.

Peer Dependencies (1)

graphql

Badge

To add a badge like this oneto 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/@graphql-codegen/visitor-plugin-common.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@graphql-codegen/visitor-plugin-common)

HTML

<a href="https://www.jsdocs.io/package/@graphql-codegen/visitor-plugin-common"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 39 minutes ago.
Package analyzed in 2435 ms.
Missing or incorrect documentation? Open an issue for this package.