@lomray/microservice-users/services/identity-provider/abstract.d.ts

Users microservice based on NodeJS & inverted json.

import { EntityManager, ObjectLiteral, Repository } from 'typeorm';
import IdProvider from "../../constants/id-provider.js";
import IdentityProvider from "../../entities/identity-provider.js";
import Profile from "../../entities/profile.js";
import User from "../../entities/user.js";
import UserRepository from "../../repositories/user.js";
interface ISingInReturn {
    user: User;
    isNew: boolean;
}
/**
 * isDenyRegister - prevent sign in if user exist
 * isDenyAuthViaRegister - prevent sign in if user exist (split sign up/sign in)
 */
type TSingInParams = {
    isDenyRegister?: boolean;
    isDenyAuthViaRegister?: boolean;
    isShouldAttachUserPhoto?: boolean;
    isShouldApproveProvider?: boolean;
} & Record<string, any>;
/**
 * Abstract class for identity providers
 */
declare abstract class Abstract {
    /**
     * Is should attach user photo
     */
    protected isShouldAttachUserPhoto: boolean;
    /**
     * Is approve provider (prevent overriding for account)
     */
    protected isShouldApproveProvider: boolean;
    /**
     * @protected
     */
    protected readonly token: string;
    /**
     * @protected
     */
    protected readonly provider: IdProvider;
    /**
     * @protected
     */
    protected readonly userRepository: UserRepository;
    /**
     * @protected
     */
    protected readonly providerRepository: Repository<IdentityProvider>;
    /**
     * @protected
     */
    protected readonly profileRepository: Repository<Profile>;
    /**
     * @protected
     */
    protected readonly manager: EntityManager;
    /**
     * @constructor
     */
    /**
     * @constructor
     */
    constructor(provider: IdProvider, token: string, manager: EntityManager);
    /**
     * Sign in user
     */
    /**
     * Sign in user
     */
    abstract signIn(params?: TSingInParams): Promise<ISingInReturn>;
    /**
     * Attach new identity provider to existing user
     */
    /**
     * Attach new identity provider to existing user
     */
    abstract attachProvider(userId: string, params?: Record<string, any>): Promise<User>;
    /**
     * Returns user from db by identity token
     */
    /**
     * Returns user from db by identity token
     */
    abstract getUserByToken(): Promise<User>;
    /**
     * Validate entities
     * @private
     */
    /**
     * Validate entities
     * @private
     */
    protected validateEntities(entitiesObj: (ObjectLiteral | undefined)[]): Promise<void>;
    /**
     * Create user and add related identity provider, update user profile
     * @protected
     */
    /**
     * Create user and add related identity provider, update user profile
     * @protected
     */
    protected createUser(entityUser: User, entityIdentityProvider: IdentityProvider, entityProfile?: Profile): Promise<User>;
    /**
     * Add new identity provider to existing user and update: profile, user
     * @protected
     */
    /**
     * Add new identity provider to existing user and update: profile, user
     * @protected
     */
    protected assign(entityIdentityProvider: IdentityProvider, user: User, profile?: Profile): Promise<User>;
}
export { Abstract as default, ISingInReturn, TSingInParams };