@accounts/server/lib/accounts-server.d.ts

Fullstack authentication and accounts-management

import * as jwt from 'jsonwebtoken';
import Emittery from 'emittery';
import { type User, type LoginResult, type Tokens, type Session, type ImpersonationUserIdentity, type ImpersonationResult, type HookListener, type DatabaseInterface, type ConnectionInformations, type DatabaseInterfaceUser, type DatabaseInterfaceSessions, type AuthenticationService } from '@accounts/types';
import { type AccountsServerOptions } from './types/accounts-server-options';
import { type EmailTemplateType } from './types/email-template-type';
import { ExecutionContext } from 'graphql-modules';
import { type AuthenticationServices } from './types/authentication-services';
declare const defaultOptions: {
    enableAutologin: boolean;
    micro: boolean;
    ambiguousErrorMessages: boolean;
    tokenSecret: string | {
        publicKey: jwt.Secret;
        privateKey: jwt.Secret;
    };
    tokenConfigs: {
        accessToken: {
            expiresIn: string;
        };
        refreshToken: {
            expiresIn: string;
        };
    };
    emailTemplates: import("./types/email-templates-type").EmailTemplatesType;
    sendMail: (mail: object) => Promise<void>;
    siteUrl: string;
    userObjectSanitizer: <CustomUser extends User = User>(user: CustomUser) => CustomUser;
    createNewSessionTokenOnRefresh: boolean;
    useInternalUserObjectSanitizer: boolean;
    useStatelessSession: boolean;
};
export declare class AccountsServer<CustomUser extends User = User> {
    services: AuthenticationServices<CustomUser> | Record<string, new (args: any) => AuthenticationService<CustomUser>>;
    private db;
    context: ExecutionContext;
    options: AccountsServerOptions<CustomUser> & typeof defaultOptions;
    private hooks;
    private micro;
    private dbSessions;
    constructor(options: AccountsServerOptions<CustomUser>, services: AuthenticationServices<CustomUser> | Record<string, new (args: any) => AuthenticationService<CustomUser>>, db: DatabaseInterface<CustomUser> | DatabaseInterfaceUser<CustomUser>, dbSessions?: DatabaseInterfaceSessions);
    private getService;
    getServices(): AuthenticationServices<CustomUser>;
    getOptions(): AccountsServerOptions<CustomUser>;
    getHooks(): Emittery;
    /**
     * Subscribe to an accounts-js event.
     * ```javascript
     * accountsServer.on(ServerHooks.ValidateLogin, ({ user }) => {
     *   // This hook is called every time a user try to login
     *   // You can use it to only allow users with verified email to login
     * });
     * ```
     */
    on(eventName: string, callback: HookListener): () => void;
    /**
     * @description Try to authenticate the user for a given service
     * @throws {@link AuthenticateWithServiceErrors}
     */
    authenticateWithService(serviceName: string, params: any, infos: ConnectionInformations): Promise<boolean>;
    /**
     * @throws {@link LoginWithServiceErrors}
     */
    loginWithService(serviceName: string, params: any, infos: ConnectionInformations): Promise<LoginResult>;
    /**
     * @description Server use only.
     * This method creates a session without authenticating any user identity.
     * Any authentication should happen before calling this function.
     * @param {User} user - The user object.
     * @param {ConnectionInformations} infos - User's connection informations.
     * @returns {Promise<LoginResult>} - Session tokens and user object.
     */
    loginWithUser(user: CustomUser, infos: ConnectionInformations): Promise<LoginResult>;
    /**
     * @description Impersonate to another user.
     * For security reasons, even if `useStatelessSession` is set to true the token will be checked against the database.
     * @param {string} accessToken - User access token.
     * @param {object} impersonated - impersonated user.
     * @param {ConnectionInformations} infos - User connection informations.
     * @returns {Promise<Object>} - ImpersonationResult
     * @throws {@link LoginWithServiceErrors}
     */
    impersonate(accessToken: string, impersonated: ImpersonationUserIdentity, infos: ConnectionInformations): Promise<ImpersonationResult>;
    /**
     * @description Refresh a user token.
     * @param {string} accessToken - User access token.
     * @param {string} refreshToken - User refresh token.
     * @param {ConnectionInformations} infos - User connection informations.
     * @returns {Promise<Object>} - LoginResult.
     * @throws {@link RefreshTokensErrors}
     */
    refreshTokens(accessToken: string, refreshToken: string, infos: ConnectionInformations): Promise<LoginResult>;
    /**
     * @description Refresh a user token.
     * @param {string} token - User session token.
     * @param {boolean} isImpersonated - Should be true if impersonating another user.
     * @param {User} user - The user object.
     * @returns {Promise<Tokens>} - Return a new accessToken and refreshToken.
     */
    createTokens({ token, isImpersonated, user, }: {
        token: string;
        isImpersonated?: boolean;
        user: CustomUser;
    }): Promise<Tokens>;
    /**
     * @description Logout a user and invalidate his session.
     * @param {string} accessToken - User access token.
     * @returns {Promise<void>} - Return a promise.
     * @throws {@link LogoutErrors}
     */
    logout(accessToken: string): Promise<void>;
    /**
     * @description Resume the current session associated to the access token. Will throw if the token
     * or the session is invalid.
     * If `useStatelessSession` is false the session validity will be checked against the database.
     * @param accessToken - User JWT access token.
     * @returns Return the user associated to the session.
     * @throws {@link ResumeSessionErrors}
     */
    resumeSession(accessToken: string): Promise<CustomUser>;
    /**
     * @description Find a session by his token.
     * @param {string} accessToken
     * @returns {Promise<Session>} - Return a session.
     * @throws {@link FindSessionByAccessTokenErrors}
     */
    findSessionByAccessToken(accessToken: string): Promise<Session>;
    /**
     * @description Find a user by his id.
     * @param {string} userId - User id.
     * @returns {Promise<Object>} - Return a user or null if not found.
     */
    findUserById(userId: string): Promise<CustomUser | null>;
    /**
     * @description Deactivate a user, the user will not be able to login until his account is reactivated.
     * @param {string} userId - User id.
     * @returns {Promise<void>} - Return a Promise.
     */
    deactivateUser(userId: string): Promise<void>;
    /**
     * @description Activate a user.
     * @param {string} userId - User id.
     * @returns {Promise<void>} - Return a Promise.
     */
    activateUser(userId: string): Promise<void>;
    prepareMail(to: string, token: string, user: CustomUser, pathFragment: string, emailTemplate: EmailTemplateType, from: string): any;
    sanitizeUser(user: CustomUser): CustomUser;
    private internalUserSanitizer;
    private defaultPrepareEmail;
    private defaultCreateTokenizedUrl;
    private createSessionToken;
    private createJwtPayload;
    private getSecretOrPublicKey;
    private getSecretOrPrivateKey;
}
export default AccountsServer;