Skip to main content

@accounts/module-core

Index

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

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

Type declaration

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

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

Type declaration

ImpersonationUserIdentityInput

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

Type declaration

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

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

Type declaration

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

MutationAuthenticateArgs

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

Type declaration

MutationImpersonateArgs

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

Type declaration

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

Type declaration

MutationVerifyAuthenticationArgs

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

Type declaration

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

Type declaration

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

Type declaration

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

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

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

Type declaration

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

UserInput

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

Type declaration

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

Type declaration