@accounts/module-core

Index

Functions

• authDirective
• authenticated
• buildSchema
• context
• createAccountsCoreModule

Interfaces

• AccountsCoreModuleConfig
• SubscriptionResolverObject
• SubscriptionSubscriberObject

Type Aliases

• AccountsContextGraphQLModules
• AccountsContextOptions
• AuthenticateParamsInput
• DirectiveResolverFn
• EmailRecord
• EmailRecordResolvers
• Exact
• ImpersonateReturn
• ImpersonateReturnResolvers
• ImpersonationUserIdentityInput
• Incremental
• InputMaybe
• IsTypeOfResolverFn
• LoginResult
• LoginResultResolvers
• MakeEmpty
• MakeMaybe
• MakeOptional
• Maybe
• Mutation
• MutationAuthenticateArgs
• MutationImpersonateArgs
• MutationRefreshTokensArgs
• MutationResolvers
• MutationVerifyAuthenticationArgs
• NextResolverFn
• Query
• QueryResolvers
• RequireFields
• Resolver
• ResolverFn
• ResolverTypeWrapper
• Resolvers
• ResolversParentTypes
• ResolversTypes
• Scalars
• SubscriptionObject
• SubscriptionResolveFn
• SubscriptionResolver
• SubscriptionSubscribeFn
• Tokens
• TokensResolvers
• TypeResolveFn
• User
• UserInput
• UserResolvers

Type Aliases

AccountsContextGraphQLModules

AccountsContextGraphQLModules<IUser>: IContext<IUser> & GraphQLModules.ModuleContext

Type parameters

• IUser: User = User

AccountsContextOptions

AccountsContextOptions<Ctx>: { createOperationController: Application[createOperationController]; ctx?: Ctx; excludeAddUserInContext?: boolean; headerName?: string }

Type parameters

• Ctx: object

Type declaration

• createOperationController: Application[createOperationController]

• optionalctx?: Ctx

• optionalexcludeAddUserInContext?: boolean

• optionalheaderName?: string

AuthenticateParamsInput

AuthenticateParamsInput: { access_token?: InputMaybe<Scalars[String][input]>; access_token_secret?: InputMaybe<Scalars[String][input]>; code?: InputMaybe<Scalars[String][input]>; password?: InputMaybe<Scalars[String][input]>; provider?: InputMaybe<Scalars[String][input]>; token?: InputMaybe<Scalars[String][input]>; user?: InputMaybe<UserInput> }

Type declaration

• optionalaccess_token?: InputMaybe<Scalars[String][input]>

• optionalaccess_token_secret?: InputMaybe<Scalars[String][input]>

• optionalcode?: InputMaybe<Scalars[String][input]>

• optionalpassword?: InputMaybe<Scalars[String][input]>

• optionalprovider?: InputMaybe<Scalars[String][input]>

• optionaltoken?: InputMaybe<Scalars[String][input]>

• optionaluser?: InputMaybe<UserInput>

DirectiveResolverFn

DirectiveResolverFn<TResult, TParent, TContext, TArgs>: (next: NextResolverFn<TResult>, parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => TResult | Promise<TResult>

Type parameters

• TResult = {}
• TParent = {}
• TContext = {}
• TArgs = {}

Type declaration

• • (next: NextResolverFn<TResult>, parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo): TResult | Promise<TResult>

  • Parameters

    • next: NextResolverFn<TResult>

    • parent: TParent

    • args: TArgs

    • context: TContext

    • info: GraphQLResolveInfo

    Returns TResult | Promise<TResult>

EmailRecord

EmailRecord: { __typename?: EmailRecord; address?: Maybe<Scalars[String][output]>; verified?: Maybe<Scalars[Boolean][output]> }

Type declaration

• optional__typename?: EmailRecord

• optionaladdress?: Maybe<Scalars[String][output]>

• optionalverified?: Maybe<Scalars[Boolean][output]>

EmailRecordResolvers

EmailRecordResolvers<ContextType, ParentType>: { __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>; address?: Resolver<Maybe<ResolversTypes[String]>, ParentType, ContextType>; verified?: Resolver<Maybe<ResolversTypes[Boolean]>, ParentType, ContextType> }

Type parameters

• ContextType = AccountsContextGraphQLModules
• ParentType: ResolversParentTypes[EmailRecord] = ResolversParentTypes[EmailRecord]

Type declaration

• optional__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>

• optionaladdress?: Resolver<Maybe<ResolversTypes[String]>, ParentType, ContextType>

• optionalverified?: Resolver<Maybe<ResolversTypes[Boolean]>, ParentType, ContextType>

Exact

Exact<T>: { [ K in keyof T ]: T[K] }

Type parameters

• T: {}

ImpersonateReturn

ImpersonateReturn: { __typename?: ImpersonateReturn; authorized?: Maybe<Scalars[Boolean][output]>; tokens?: Maybe<Tokens>; user?: Maybe<User> }

Type declaration

• optional__typename?: ImpersonateReturn

• optionalauthorized?: Maybe<Scalars[Boolean][output]>

• optionaltokens?: Maybe<Tokens>

• optionaluser?: Maybe<User>

ImpersonateReturnResolvers

ImpersonateReturnResolvers<ContextType, ParentType>: { __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>; authorized?: Resolver<Maybe<ResolversTypes[Boolean]>, ParentType, ContextType>; tokens?: Resolver<Maybe<ResolversTypes[Tokens]>, ParentType, ContextType>; user?: Resolver<Maybe<ResolversTypes[User]>, ParentType, ContextType> }

Type parameters

• ContextType = AccountsContextGraphQLModules
• ParentType: ResolversParentTypes[ImpersonateReturn] = ResolversParentTypes[ImpersonateReturn]

Type declaration

• optional__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>

• optionalauthorized?: Resolver<Maybe<ResolversTypes[Boolean]>, ParentType, ContextType>

• optionaltokens?: Resolver<Maybe<ResolversTypes[Tokens]>, ParentType, ContextType>

• optionaluser?: Resolver<Maybe<ResolversTypes[User]>, ParentType, ContextType>

ImpersonationUserIdentityInput

ImpersonationUserIdentityInput: { email?: InputMaybe<Scalars[String][input]>; userId?: InputMaybe<Scalars[String][input]>; username?: InputMaybe<Scalars[String][input]> }

Type declaration

• optionalemail?: InputMaybe<Scalars[String][input]>

• optionaluserId?: InputMaybe<Scalars[String][input]>

• optionalusername?: InputMaybe<Scalars[String][input]>

Incremental

Incremental<T>: T | { [ P in keyof T ]?: P extends $fragmentName | __typename ? T[P] : never }

Type parameters

• T

InputMaybe

InputMaybe<T>: Maybe<T>

Type parameters

• T

IsTypeOfResolverFn

IsTypeOfResolverFn<T, TContext>: (obj: T, context: TContext, info: GraphQLResolveInfo) => boolean | Promise<boolean>

Type parameters

• T = {}
• TContext = {}

Type declaration

• • (obj: T, context: TContext, info: GraphQLResolveInfo): boolean | Promise<boolean>

  • Parameters

    • obj: T

    • context: TContext

    • info: GraphQLResolveInfo

    Returns boolean | Promise<boolean>

LoginResult

LoginResult: { __typename?: LoginResult; sessionId?: Maybe<Scalars[String][output]>; tokens?: Maybe<Tokens>; user?: Maybe<User> }

Type declaration

• optional__typename?: LoginResult

• optionalsessionId?: Maybe<Scalars[String][output]>

• optionaltokens?: Maybe<Tokens>

• optionaluser?: Maybe<User>

LoginResultResolvers

LoginResultResolvers<ContextType, ParentType>: { __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>; sessionId?: Resolver<Maybe<ResolversTypes[String]>, ParentType, ContextType>; tokens?: Resolver<Maybe<ResolversTypes[Tokens]>, ParentType, ContextType>; user?: Resolver<Maybe<ResolversTypes[User]>, ParentType, ContextType> }

Type parameters

• ContextType = AccountsContextGraphQLModules
• ParentType: ResolversParentTypes[LoginResult] = ResolversParentTypes[LoginResult]

Type declaration

• optional__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>

• optionalsessionId?: Resolver<Maybe<ResolversTypes[String]>, ParentType, ContextType>

• optionaltokens?: Resolver<Maybe<ResolversTypes[Tokens]>, ParentType, ContextType>

• optionaluser?: Resolver<Maybe<ResolversTypes[User]>, ParentType, ContextType>

MakeEmpty

MakeEmpty<T, K>: { [ _ in K ]?: never }

Type parameters

• T: {}
• K: keyof T

MakeMaybe

MakeMaybe<T, K>: Omit<T, K> & { [ SubKey in K ]: Maybe<T[SubKey]> }

Type parameters

• T
• K: keyof T

MakeOptional

MakeOptional<T, K>: Omit<T, K> & { [ SubKey in K ]?: Maybe<T[SubKey]> }

Type parameters

• T
• K: keyof T

Maybe

Maybe<T>: T | null

Type parameters

• T

Mutation

Mutation: { __typename?: Mutation; authenticate?: Maybe<LoginResult>; impersonate?: Maybe<ImpersonateReturn>; logout?: Maybe<Scalars[Boolean][output]>; refreshTokens?: Maybe<LoginResult>; verifyAuthentication?: Maybe<Scalars[Boolean][output]> }

Type declaration

• optional__typename?: Mutation

• optionalauthenticate?: Maybe<LoginResult>

• optionalimpersonate?: Maybe<ImpersonateReturn>

• optionallogout?: Maybe<Scalars[Boolean][output]>

• optionalrefreshTokens?: Maybe<LoginResult>

• optionalverifyAuthentication?: Maybe<Scalars[Boolean][output]>

MutationAuthenticateArgs

MutationAuthenticateArgs: { params: AuthenticateParamsInput; serviceName: Scalars[String][input] }

Type declaration

• params: AuthenticateParamsInput

• serviceName: Scalars[String][input]

MutationImpersonateArgs

MutationImpersonateArgs: { accessToken: Scalars[String][input]; impersonated: ImpersonationUserIdentityInput }

Type declaration

• accessToken: Scalars[String][input]

• impersonated: ImpersonationUserIdentityInput

MutationRefreshTokensArgs

MutationRefreshTokensArgs: { accessToken: Scalars[String][input]; refreshToken: Scalars[String][input] }

Type declaration

• accessToken: Scalars[String][input]

• refreshToken: Scalars[String][input]

MutationResolvers

MutationResolvers<ContextType, ParentType>: { authenticate?: Resolver<Maybe<ResolversTypes[LoginResult]>, ParentType, ContextType, RequireFields<MutationAuthenticateArgs, params | serviceName>>; impersonate?: Resolver<Maybe<ResolversTypes[ImpersonateReturn]>, ParentType, ContextType, RequireFields<MutationImpersonateArgs, accessToken | impersonated>>; logout?: Resolver<Maybe<ResolversTypes[Boolean]>, ParentType, ContextType>; refreshTokens?: Resolver<Maybe<ResolversTypes[LoginResult]>, ParentType, ContextType, RequireFields<MutationRefreshTokensArgs, accessToken | refreshToken>>; verifyAuthentication?: Resolver<Maybe<ResolversTypes[Boolean]>, ParentType, ContextType, RequireFields<MutationVerifyAuthenticationArgs, params | serviceName>> }

Type parameters

• ContextType = AccountsContextGraphQLModules
• ParentType: ResolversParentTypes[Mutation] = ResolversParentTypes[Mutation]

Type declaration

• optionalauthenticate?: Resolver<Maybe<ResolversTypes[LoginResult]>, ParentType, ContextType, RequireFields<MutationAuthenticateArgs, params | serviceName>>

• optionalimpersonate?: Resolver<Maybe<ResolversTypes[ImpersonateReturn]>, ParentType, ContextType, RequireFields<MutationImpersonateArgs, accessToken | impersonated>>

• optionallogout?: Resolver<Maybe<ResolversTypes[Boolean]>, ParentType, ContextType>

• optionalrefreshTokens?: Resolver<Maybe<ResolversTypes[LoginResult]>, ParentType, ContextType, RequireFields<MutationRefreshTokensArgs, accessToken | refreshToken>>

• optionalverifyAuthentication?: Resolver<Maybe<ResolversTypes[Boolean]>, ParentType, ContextType, RequireFields<MutationVerifyAuthenticationArgs, params | serviceName>>

MutationVerifyAuthenticationArgs

MutationVerifyAuthenticationArgs: { params: AuthenticateParamsInput; serviceName: Scalars[String][input] }

Type declaration

• params: AuthenticateParamsInput

• serviceName: Scalars[String][input]

NextResolverFn

NextResolverFn<T>: () => Promise<T>

Type parameters

• T

Type declaration

• • (): Promise<T>

  • Returns Promise<T>

Query

Query: { __typename?: Query; getUser?: Maybe<User> }

Type declaration

• optional__typename?: Query

• optionalgetUser?: Maybe<User>

QueryResolvers

QueryResolvers<ContextType, ParentType>: { getUser?: Resolver<Maybe<ResolversTypes[User]>, ParentType, ContextType> }

Type parameters

• ContextType = AccountsContextGraphQLModules
• ParentType: ResolversParentTypes[Query] = ResolversParentTypes[Query]

Type declaration

• optionalgetUser?: Resolver<Maybe<ResolversTypes[User]>, ParentType, ContextType>

RequireFields

RequireFields<T, K>: Omit<T, K> & { [ P in K ]-?: NonNullable<T[P]> }

Type parameters

• T
• K: keyof T

Resolver

Resolver<TResult, TParent, TContext, TArgs>: ResolverFn<TResult, TParent, TContext, TArgs>

Type parameters

• TResult
• TParent = {}
• TContext = {}
• TArgs = {}

ResolverFn

ResolverFn<TResult, TParent, TContext, TArgs>: (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => Promise<TResult> | TResult

Type parameters

• TResult
• TParent
• TContext
• TArgs

Type declaration

• • (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo): Promise<TResult> | TResult

  • Parameters

    • parent: TParent

    • args: TArgs

    • context: TContext

    • info: GraphQLResolveInfo

    Returns Promise<TResult> | TResult

ResolverTypeWrapper

ResolverTypeWrapper<T>: Promise<T> | T

Type parameters

• T

Resolvers

Resolvers<ContextType>: { EmailRecord?: EmailRecordResolvers<ContextType>; ImpersonateReturn?: ImpersonateReturnResolvers<ContextType>; LoginResult?: LoginResultResolvers<ContextType>; Mutation?: MutationResolvers<ContextType>; Query?: QueryResolvers<ContextType>; Tokens?: TokensResolvers<ContextType>; User?: UserResolvers<ContextType> }

Type parameters

• ContextType = AccountsContextGraphQLModules

Type declaration

• optionalEmailRecord?: EmailRecordResolvers<ContextType>

• optionalImpersonateReturn?: ImpersonateReturnResolvers<ContextType>

• optionalLoginResult?: LoginResultResolvers<ContextType>

• optionalMutation?: MutationResolvers<ContextType>

• optionalQuery?: QueryResolvers<ContextType>

• optionalTokens?: TokensResolvers<ContextType>

• optionalUser?: UserResolvers<ContextType>

ResolversParentTypes

ResolversParentTypes: { AuthenticateParamsInput: AuthenticateParamsInput; Boolean: Scalars[Boolean][output]; EmailRecord: EmailRecord; ID: Scalars[ID][output]; ImpersonateReturn: ImpersonateReturn; ImpersonationUserIdentityInput: ImpersonationUserIdentityInput; LoginResult: LoginResult; Mutation: {}; Query: {}; String: Scalars[String][output]; Tokens: Tokens; User: User; UserInput: UserInput }

Mapping between all available schema types and the resolvers parents

---

Type declaration

• AuthenticateParamsInput: AuthenticateParamsInput

• Boolean: Scalars[Boolean][output]

• EmailRecord: EmailRecord

• ID: Scalars[ID][output]

• ImpersonateReturn: ImpersonateReturn

• ImpersonationUserIdentityInput: ImpersonationUserIdentityInput

• LoginResult: LoginResult

• Mutation: {}

• Query: {}

• String: Scalars[String][output]

• Tokens: Tokens

• User: User

• UserInput: UserInput

ResolversTypes

ResolversTypes: { AuthenticateParamsInput: AuthenticateParamsInput; Boolean: ResolverTypeWrapper<Scalars[Boolean][output]>; EmailRecord: ResolverTypeWrapper<EmailRecord>; ID: ResolverTypeWrapper<Scalars[ID][output]>; ImpersonateReturn: ResolverTypeWrapper<ImpersonateReturn>; ImpersonationUserIdentityInput: ImpersonationUserIdentityInput; LoginResult: ResolverTypeWrapper<LoginResult>; Mutation: ResolverTypeWrapper<{}>; Query: ResolverTypeWrapper<{}>; String: ResolverTypeWrapper<Scalars[String][output]>; Tokens: ResolverTypeWrapper<Tokens>; User: ResolverTypeWrapper<User>; UserInput: UserInput }

Mapping between all available schema types and the resolvers types

---

Type declaration

• AuthenticateParamsInput: AuthenticateParamsInput

• Boolean: ResolverTypeWrapper<Scalars[Boolean][output]>

• EmailRecord: ResolverTypeWrapper<EmailRecord>

• ID: ResolverTypeWrapper<Scalars[ID][output]>

• ImpersonateReturn: ResolverTypeWrapper<ImpersonateReturn>

• ImpersonationUserIdentityInput: ImpersonationUserIdentityInput

• LoginResult: ResolverTypeWrapper<LoginResult>

• Mutation: ResolverTypeWrapper<{}>

• Query: ResolverTypeWrapper<{}>

• String: ResolverTypeWrapper<Scalars[String][output]>

• Tokens: ResolverTypeWrapper<Tokens>

• User: ResolverTypeWrapper<User>

• UserInput: UserInput

Scalars

Scalars: { Boolean: { input: boolean; output: boolean }; Float: { input: number; output: number }; ID: { input: string; output: string }; Int: { input: number; output: number }; String: { input: string; output: string } }

All built-in and custom scalars, mapped to their actual values

---

Type declaration

• Boolean: { input: boolean; output: boolean }

  • input: boolean

  • output: boolean

• Float: { input: number; output: number }

  • input: number

  • output: number

• ID: { input: string; output: string }

  • input: string

  • output: string

• Int: { input: number; output: number }

  • input: number

  • output: number

• String: { input: string; output: string }

  • input: string

  • output: string

SubscriptionObject

SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>: SubscriptionSubscriberObject<TResult, TKey, TParent, TContext, TArgs> | SubscriptionResolverObject<TResult, TParent, TContext, TArgs>

Type parameters

• TResult
• TKey: string
• TParent
• TContext
• TArgs

SubscriptionResolveFn

SubscriptionResolveFn<TResult, TParent, TContext, TArgs>: (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => TResult | Promise<TResult>

Type parameters

• TResult
• TParent
• TContext
• TArgs

Type declaration

• • (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo): TResult | Promise<TResult>

  • Parameters

    • parent: TParent

    • args: TArgs

    • context: TContext

    • info: GraphQLResolveInfo

    Returns TResult | Promise<TResult>

SubscriptionResolver

SubscriptionResolver<TResult, TKey, TParent, TContext, TArgs>: (...args: any[]) => SubscriptionObject<TResult, TKey, TParent, TContext, TArgs> | SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>

Type parameters

• TResult
• TKey: string
• TParent = {}
• TContext = {}
• TArgs = {}

SubscriptionSubscribeFn

SubscriptionSubscribeFn<TResult, TParent, TContext, TArgs>: (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => AsyncIterable<TResult> | Promise<AsyncIterable<TResult>>

Type parameters

• TResult
• TParent
• TContext
• TArgs

Type declaration

• • (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo): AsyncIterable<TResult> | Promise<AsyncIterable<TResult>>

  • Parameters

    • parent: TParent

    • args: TArgs

    • context: TContext

    • info: GraphQLResolveInfo

    Returns AsyncIterable<TResult> | Promise<AsyncIterable<TResult>>

Tokens

Tokens: { __typename?: Tokens; accessToken?: Maybe<Scalars[String][output]>; refreshToken?: Maybe<Scalars[String][output]> }

Type declaration

• optional__typename?: Tokens

• optionalaccessToken?: Maybe<Scalars[String][output]>

• optionalrefreshToken?: Maybe<Scalars[String][output]>

TokensResolvers

TokensResolvers<ContextType, ParentType>: { __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>; accessToken?: Resolver<Maybe<ResolversTypes[String]>, ParentType, ContextType>; refreshToken?: Resolver<Maybe<ResolversTypes[String]>, ParentType, ContextType> }

Type parameters

• ContextType = AccountsContextGraphQLModules
• ParentType: ResolversParentTypes[Tokens] = ResolversParentTypes[Tokens]

Type declaration

• optional__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>

• optionalaccessToken?: Resolver<Maybe<ResolversTypes[String]>, ParentType, ContextType>

• optionalrefreshToken?: Resolver<Maybe<ResolversTypes[String]>, ParentType, ContextType>

TypeResolveFn

TypeResolveFn<TTypes, TParent, TContext>: (parent: TParent, context: TContext, info: GraphQLResolveInfo) => Maybe<TTypes> | Promise<Maybe<TTypes>>

Type parameters

• TTypes
• TParent = {}
• TContext = {}

Type declaration

• • (parent: TParent, context: TContext, info: GraphQLResolveInfo): Maybe<TTypes> | Promise<Maybe<TTypes>>

  • Parameters

    • parent: TParent

    • context: TContext

    • info: GraphQLResolveInfo

    Returns Maybe<TTypes> | Promise<Maybe<TTypes>>

User

User: { __typename?: User; emails?: Maybe<EmailRecord[]>; id: Scalars[ID][output]; username?: Maybe<Scalars[String][output]> }

Type declaration

• optional__typename?: User

• optionalemails?: Maybe<EmailRecord[]>

• id: Scalars[ID][output]

• optionalusername?: Maybe<Scalars[String][output]>

UserInput

UserInput: { email?: InputMaybe<Scalars[String][input]>; id?: InputMaybe<Scalars[ID][input]>; username?: InputMaybe<Scalars[String][input]> }

Type declaration

• optionalemail?: InputMaybe<Scalars[String][input]>

• optionalid?: InputMaybe<Scalars[ID][input]>

• optionalusername?: InputMaybe<Scalars[String][input]>

UserResolvers

UserResolvers<ContextType, ParentType>: { __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>; emails?: Resolver<Maybe<ResolversTypes[EmailRecord][]>, ParentType, ContextType>; id?: Resolver<ResolversTypes[ID], ParentType, ContextType>; username?: Resolver<Maybe<ResolversTypes[String]>, ParentType, ContextType> }

Type parameters

• ContextType = AccountsContextGraphQLModules
• ParentType: ResolversParentTypes[User] = ResolversParentTypes[User]

Type declaration

• optional__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>

• optionalemails?: Resolver<Maybe<ResolversTypes[EmailRecord][]>, ParentType, ContextType>

• optionalid?: Resolver<ResolversTypes[ID], ParentType, ContextType>

• optionalusername?: Resolver<Maybe<ResolversTypes[String]>, ParentType, ContextType>