will-auth/index.d.ts

authentication and authorization module

import { KnModel, KnHandler, LoggerInterface, DBConnector, TrackingInfo, OperationInfo } from "will-db";
import { ResultSet, RecordSet } from "will-sql";
import { JSONReply } from "will-api";
import { UserTokenInfo, PasswordVerify } from "will-lib"
import { Request, Response } from 'express';

export declare class AssureHandler {
    static isExceptPath(req: any): boolean;
    static doAuthorizeFilter(ctx: ContextInfo, req: any): Promise<ContextInfo>;
    static doAuthenticateFilter(ctx: ContextInfo, req: any): Promise<any>;
    static doAuthorize(ctx: ContextInfo): Promise<ContextInfo>;
    static doAuthenticate(ctx: ContextInfo): Promise<any>;
}

export declare class AttachHandler extends SchemeHandler {
    model: KnModel;
    handlers: {
        name: string;
    }[];
    get(context: ContextInfo): Promise<RecordSet>;
    protected doGet(context: ContextInfo, model: KnModel): Promise<RecordSet>;
    attach(context: ContextInfo): Promise<RecordSet>;
    protected doAttach(context: ContextInfo, model: KnModel): Promise<RecordSet>;
}

export declare class AuthenticateHandler extends SchemeHandler {
    model: KnModel;
    handlers: {
        name: string;
    }[];
    authenticate(context: ContextInfo): Promise<UserTokenInfo | undefined>;
    protected doAuthenticate(context: ContextInfo, model: KnModel): Promise<UserTokenInfo | undefined>;
}

export declare class AuthorizeHandler extends SchemeHandler {
    model: KnModel;
    handlers: {
        name: string;
    }[];
    authorize(context: ContextInfo): Promise<UserTokenInfo | undefined>;
    doAuthorize(context: ContextInfo, model: KnModel): Promise<UserTokenInfo | undefined>;
    getAuthorizeTokenInfo(db: DBConnector, token: string): Promise<UserTokenInfo | undefined>;
    getAuthorizeToken(db: DBConnector, atoken: AuthenTokenData): Promise<UserTokenInfo | undefined>;
}

export declare class BaseHandler extends KnHandler {
    accessor?: Accessor;
    section: string;
    constructor(model?: KnModel, settings?: KnSetting, accessor?: Accessor);
    protected getAccessor(conn: DBConnector, useruuid: string): Promise<Accessor | undefined>;
    protected retainAccessor(conn: DBConnector, useruuid: string): Promise<void>;
    getCurrentUser(): string;
    getAuthorizationInfo(context: ContextInfo): AuthorizationInfo | undefined;
    getTokenKey(context: ContextInfo): string | undefined;
    getUserTokenInfo(context: ContextInfo, onlyMeta?: boolean, db?: DBConnector): Promise<UserTokenInfo | undefined>;
    getUserTokenInfoByToken(context: ContextInfo, db?: DBConnector): Promise<UserTokenInfo | undefined>;
    getUserDiffie(userInfo: UserTokenInfo | undefined): Promise<DH | undefined>;
    getUserDH(context: ContextInfo): Promise<DH | undefined>;
    getAuthenToken(context: ContextInfo, verifyTokenKey?: boolean, verifyIdentifier?: boolean): Promise<AuthenTokenData | undefined>;
    exposeContext(context: ContextInfo, includeChiperData?: boolean): Promise<ContextInfo>;
    isCipherData(context: ContextInfo): boolean;
    chipherData(context: ContextInfo, data?: any): Promise<any>;
    validateAuthenToken(context: ContextInfo): Promise<AuthenTokenData | undefined>;
    validateParameters(params: any, ...args: string[]): ValidateInfo;
    recordNotFound(): Promise<RecordSet>;
    notImplementation(): Promise<RecordSet>;
    createRecordSet(result?: ResultSet): RecordSet;
}

export declare class CaptchaHandler extends SchemeHandler {
    model: KnModel;
    handlers: {
        name: string;
    }[];
    verify(context: ContextInfo): Promise<RecordSet>;
    protected doCreate(context: ContextInfo, model: KnModel): Promise<RecordSet>;
    protected doVerify(context: ContextInfo, model: KnModel): Promise<RecordSet>;
}

export declare class ChangePasswordHandler extends SchemeHandler {
    model: KnModel;
    handlers: {
        name: string;
    }[];
    change(context: ContextInfo): Promise<RecordSet>;
    policy(context: ContextInfo): Promise<{
        policy: string[];
    }>;
    protected doChange(context: ContextInfo, model: KnModel): Promise<RecordSet>;
    checkChangePassword(puserid: string, puserpass: string, pcnfpass: string): VerifyError | null;
    processChangePassword(db: DBConnector, puserid: string, puserpass: string, poldpass: string): Promise<RecordSet>;
    changeUserPassword(db: DBConnector, userid: string, pwd: string, newpwd: string, site?: string, date?: Date): Promise<PasswordVerify>;
    protected doPolicy(context: ContextInfo, model: KnModel): Promise<{
        policy: string[];
    }>;
}

export declare class DiffieHandler extends SchemeHandler {
    model: KnModel;
    handlers: {
        name: string;
    }[];
    dh(context: ContextInfo): Promise<any>;
    diffie(context: ContextInfo): Promise<any>;
    doDiffie(context: ContextInfo, model: KnModel): Promise<any>;
    createDiffie(context: ContextInfo): Promise<DH>;
    createDiffieInfo(dh: DH): DiffieInfo;
    doSaveDiffie(context: ContextInfo, model: KnModel, dh: DH): Promise<ResultSet | undefined>;
    saveDiffie(db: DBConnector, userInfo: UserTokenInfo, dh: DH): Promise<ResultSet>;
    protected doUpdate(context: any, model: KnModel): Promise<RecordSet>;
    encrypt(context: ContextInfo): Promise<any>;
    decrypt(context: ContextInfo): Promise<any>;
}

export declare class ForgotPasswordHandler extends SchemeHandler {
    model: KnModel;
    handlers: {
        name: string;
    }[];
    password(context: ContextInfo): Promise<RecordSet>;
    protected doPassword(context: ContextInfo, model: KnModel): Promise<RecordSet>;
    forgotPassword(db: DBConnector, userid: string, site?: string, date?: Date): Promise<PasswordVerify>;
}

export declare class LoginHandler extends SchemeHandler {
    model: KnModel;
    handlers: {
        name: string;
    }[];
    logincallback(context: ContextInfo): Promise<LoginInfoContents>;
    logoutcallback(context: ContextInfo): Promise<LogoutInfoContents>;
    anonymouslogin(context: ContextInfo): Promise<AnonymousInfoContents>;
    protected doLoginCallback(context: ContextInfo, model: KnModel): Promise<LoginInfoContents>;
    processLogin(context: ContextInfo, db: DBConnector, useruuid: string, token: string): Promise<LoginInfoContents>;
    composeResponseInfo(row: any): LoginInfoContents;
    processLoginByNonce(context: ContextInfo, db: DBConnector, nonce: string, code: string): Promise<LoginInfoContents>;
    protected doLogoutCallback(context: ContextInfo, model: KnModel): Promise<LogoutInfoContents>;
    processLogout(db: DBConnector, token: string): Promise<ResultSet>;
    doAnonymousLogin(context: ContextInfo, model: KnModel): Promise<AnonymousInfoContents>;
}

export declare class ProfileHandler extends SchemeHandler {
    model: KnModel;
    handlers: {
        name: string;
    }[];
    get(context: ContextInfo): Promise<RecordSet>;
    protected doGet(context: ContextInfo, model: KnModel): Promise<RecordSet>;
    getUserProfile(db: DBConnector, useruuid: string): Promise<ResultSet>;
    contents(context: ContextInfo): Promise<ResultSet>;
    protected doContents(context: ContextInfo, model: KnModel): Promise<ResultSet>;
    processUpdateUserContents(db: DBConnector, useruuid: string, usercontents?: string): Promise<ResultSet>;
    protected doUpdate(context: ContextInfo, model: KnModel): Promise<RecordSet>;
    processUpdateUserInfo(db: DBConnector, useruuid: string, displayname?: string): Promise<ResultSet>;
    edit(context: ContextInfo): Promise<any>;
    protected doEdit(context: ContextInfo, model: KnModel): Promise<any>;
}

export declare class SchemeHandler extends SystemHandler {
    protected doClear(context: any, model: KnModel): Promise<RecordSet>;
    protected doCreate(context: any, model: KnModel): Promise<RecordSet>;
    protected doExecute(context: any, model: KnModel): Promise<RecordSet>;
    protected doList(context: any, model: KnModel): Promise<RecordSet>;
    protected doFind(context: any, model: KnModel): Promise<RecordSet>;
    protected doInsert(context: any, model: KnModel): Promise<RecordSet>;
    protected doRetrieve(context: any, model: KnModel): Promise<RecordSet>;
    protected doUpdate(context: any, model: KnModel): Promise<RecordSet>;
    protected doRemove(context: any, model: KnModel): Promise<RecordSet>;
    protected doCollect(context: any, model: KnModel): Promise<RecordSet>;
}

export declare class SigninHandler extends SchemeHandler {
    model: KnModel;
    handlers: {
        name: string;
    }[];
    protected getSigninInfo(context: ContextInfo): SigninInfo;
    signin(context: ContextInfo): Promise<JSONReply>;
    protected doSignin(context: ContextInfo, model: KnModel): Promise<JSONReply>;
    doSigninByDomain(context: ContextInfo, model: KnModel, signinfo: SigninInfo, db: DBConnector): Promise<JSONReply>;
    doSigninByConfigure(context: ContextInfo, model: KnModel, signinfo: SigninInfo, db: DBConnector): Promise<JSONReply>;
    processSigninInternalSystem(context: ContextInfo, signinfo: SigninInfo, db: DBConnector, loginfo?: Object): Promise<JSONReply>;
    processSigninActiveDirectory(context: ContextInfo, signinfo: SigninInfo, db: DBConnector, config?: ActiveConfig, loginfo?: Object): Promise<JSONReply>;
    processSigninPromptSystem(context: ContextInfo, signinfo: SigninInfo, db: DBConnector, config?: PromptConfig, loginfo?: Object): Promise<JSONReply>;
    composeResponseBody(body: Map<string, Object>, token: UserToken, username: string, row: any, tempmatch?: boolean, dhinfo?: DiffieInfo): void;
    createUserAccess(db: DBConnector, usrinfo: UserAccessInfo): Promise<UserToken>;
    createDiffie(context: ContextInfo, db: DBConnector, token: UserToken): Promise<DiffieInfo | undefined>;
    updateUserAccess(db: DBConnector, userid: string): Promise<void>;
    updateUserLock(db: DBConnector, username: string, lockflag: string): Promise<void>;
    accesstoken(context: ContextInfo): Promise<Map<string, Object>>;
    protected doAccessToken(context: ContextInfo, model: KnModel): Promise<Map<string, Object>>;
    processAccessToken(db: DBConnector, useruuid: string): Promise<Map<string, Object>>;
    fetchtoken(context: ContextInfo): Promise<Map<string, Object>>;
    protected doFetchToken(context: ContextInfo, model: KnModel): Promise<Map<string, Object>>;
    signout(context: ContextInfo): Promise<Map<string, Object>>;
    doSignout(context: ContextInfo, model: KnModel): Promise<Map<string, Object>>;
    processSignout(db: DBConnector, useruuid: string): Promise<Map<string, Object>>;
    loginWow(userid: string, pwd: string, site?: string): Promise<any>;
}

export declare class SystemHandler extends BaseHandler {
    protected exposeOperation(context: any, model: KnModel, operation: OperationInfo): Promise<void>;
    track(context: ContextInfo, info: TrackingInfo): Promise<void>;
}

export declare class TrackingHandler extends BaseHandler {
    model: KnModel;
    trackInfo?: TrackingInfo;
    insert(context: any): Promise<ResultSet>;
    protected doInsert(context: any, model: KnModel): Promise<RecordSet>;
}

export declare class Accessor {
    readonly useruuid: string;
    readonly userid: string;
    readonly authtoken: string;
    readonly userinfo?: any;
    constructor(useruuid: string, userid: string, authtoken: string, userinfo?: any);
}

export interface LoginInfoContents {
    authToken: string;
    userUuid: string;
    textures: any[];
    email: string;
    displayName: string;
    userPrincipalName: string;
    userContents: any;
    accessContents: any;
    info?: any;
}
export interface LogoutInfoContents {
    authToken: string;
}
export interface AnonymousInfoContents {
    userUuid: string;
    authToken: string;
}
export interface ContextInfo {
    params: any;
    meta: any;
    options?: any;
}
export interface AuthorizationInfo {
    authorization: string;
    client?: string;
}
export interface SigninInfo {
    username: string;
    password: string;
    site?: string;
}
export interface DiffieInfo {
    prime: string;
    generator: string;
    publickey: string;
}
export interface UserAccessInfo {
    userid: string;
    site?: string;
    code?: string;
    state?: string;
    nonce?: string;
    loginfo?: Object;
}
export interface CipherData {
    data: string;
}
export interface ValidateInfo {
    valid: boolean;
    info?: string;
}
export declare const CircularReplacer: () => (key: any, value: any) => any;

export declare class UserToken {
    useruuid: string;
    expiretimes: number;
    code: string;
    state: string;
    nonce: string;
    authtoken: string;
    constructor(useruuid: string, expiretimes: number, code: string, state: string, nonce: string, authtoken: string);
}

export declare class VerifyError extends Error {
    readonly code: number;
    readonly errno: number | undefined;
    constructor(message: string, code: number, errno?: number);
}

export declare abstract class BaseRouter {
    readonly service: Service;
    readonly logger: LoggerInterface;
    dir: string;
    constructor(service: Service, dir?: string);
    buildContext(req: Request, pid?: string): ContextInfo;
    createContext(req: Request, pid?: string): Promise<ContextInfo>;
    chipherData(context: ContextInfo, data?: any): Promise<any | undefined>;
    call(serviceName: string, req: Request): Promise<any>;
    authorize(req: Request): Promise<ContextInfo>;
}

export declare class CallbackRouter extends BaseRouter {
    doLoginCallback(req: Request, res: Response): Promise<void>;
    doLogoutCallback(req: Request, res: Response): Promise<void>;
    doAnonymousLogin(req: Request, res: Response): Promise<void>;
    doUpdateUserContents(req: Request, res: Response): Promise<void>;
    doUpdateUserInfo(req: Request, res: Response): Promise<void>;
    doSignin(req: Request, res: Response): Promise<void>;
    doFetchToken(req: Request, res: Response): Promise<void>;
    doAccessToken(req: Request, res: Response): Promise<void>;
    doSignout(req: Request, res: Response): Promise<void>;
}

export declare class DiffieRouter extends BaseRouter {
    doDiffie(req: Request, res: Response): Promise<void>;
    doEncrypt(req: Request, res: Response): Promise<void>;
    doDecrypt(req: Request, res: Response): Promise<void>;
    doUpdate(req: Request, res: Response): Promise<void>;
}

export declare class UploadRouter extends BaseRouter {
    doUpload(req: Request, res: Response): void;
    protected doUploadFile(req: Request, res: Response): Promise<void>;
}

export declare class Responser {
    static createError(model: string, method: string, err: any): JSONReply;
    static createDbError(model: string, method: string, err: any): JSONReply;
    static responseError(res: Response, err: any, model: string, method: string): void;
}