auth/lib/schema/auth.ts

import { JwtPayload } from 'jsonwebtoken';
import { Document, InferSchemaType, Model, Schema, StringSchemaDefinition, Types } from 'mongoose';

import { Strategy } from './strategy';
import { STRATEGIES } from '../constants/strategies';
import { TokenProps, sign, verify as verifyJwt } from '../utils/jwt';
import { encrypt, verify as verifyPassword } from '../utils/password';
import { generateResetToken } from '../utils/tokens';

export type Auth = {
    is2FA?: boolean;
    record: StringSchemaDefinition;
    username: string;
}

export type AuthPrivate = Auth & {
    strategies: Types.ArraySubdocument<Strategy>;
}

export interface AuthMethods {
    authenticate(password: string): boolean;
    getAuthStrategy(method?: STRATEGIES): Strategy | false;
    getResetLink(route: string): Promise<string | undefined>;
    getResetToken(): Promise<string | undefined>;
    getToken(props?: Omit<TokenProps, 'sub'>): string;
    setPassword(password: string): Promise<boolean>;
}

export interface AuthModel extends Model<AuthPrivate, {}, AuthMethods> {
    authenticate(password: any): boolean;
    findByUsername(username: string): Promise<AuthModel & AuthPrivate>;
    isUsernameAvailable(username: string): Promise<boolean>;
    findUserForReset(strategy: STRATEGIES, token: string): Promise<Strategy | undefined>;
    resetPassword(token: string, password: string): Promise<boolean>;
} 

export const AuthSchema = new Schema<AuthPrivate, AuthModel, AuthMethods>(
    {
        is2FA: { type: Boolean, default: false },
        record: { type: Types.ObjectId },
        strategies: { type: Types.ArraySubdocument<Strategy>, required: true },
        username: { type: String, required: true, unique: true },
    },
    {
        minimize: true,
        timestamps: true,
    },
);

AuthSchema.methods = {
    authenticate: function(password: string) {
        const strategy = this.getAuthStrategy(STRATEGIES.LOCAL);
        return !!strategy && verifyPassword(password, strategy.key);
    },

    getAuthStrategy: function(method = STRATEGIES.LOCAL) {
        return this.strategies.filter((strategy: Strategy) => strategy.method === method).pop() || false;
    },

    getToken: function(props = {}) {
        return sign({
            sub: this._id,
            ...props,
        });
    },

    getResetLink: async function (route) {
        const resetToken = await this.getResetToken();
        if (resetToken) {
            let resetRoute = route;
            resetRoute = resetRoute.replace(':user_id', this._id);
            resetRoute = resetRoute.replace(':reset_token?', resetToken);
            const resetUrl = `${process.env.URL}${resetRoute}`;
            console.log('[sendPasswordReset] resetUrl:', resetUrl);
            return resetUrl;
        }
    },

    getResetToken: async function () {
        const { key, token } = generateResetToken(this._id);
        this.resetCheckBit = key;
        await this.save().catch(() => undefined);
        return token;
    },
    
    setPassword: async function (password) {
        const key = encrypt(password);
        const hasLocalStrategy = !!this.getAuthStrategy(STRATEGIES.LOCAL);
        const strategy = {
            key,
            method: STRATEGIES.LOCAL,
            resetToken: undefined,
        };
  
        if (hasLocalStrategy) {
            await this.model('User').findOneAndUpdate(
                { _id: this._id, 'strategies.method': STRATEGIES.LOCAL },
                { $set: { 'strategies.$': strategy } },
                { upsert: true },
            ).catch();
            return true;
        }
        this.credentials.push(strategy);
        await this.save().catch(() => false);
        return true;
    },
};

AuthSchema.statics = {
    // authenticateAndGetRecordLocator: async function (username, password) {
    //     const auth = await this.findByUserName(username);
    //     if (auth && auth.authenticate(password)) {
    //         return auth?.record;
    //     }
    //     return false;
    // },

    findByUsername: async function (username) {
        return this.findOne({ username });
    },

    isUsernameAvailable: async function (username) {
        return !!!this.findByUsername(username);
    },

    resetPassword: async function (token, password) {
        const decoded = verifyJwt(token);
        const { sub, key } = decoded as JwtPayload;
        const auth = await this.findOne({ _id: sub, 'strategies.resetToken': key }).catch();
        return !!auth && auth.setPassword(password);
    },
};

export type AuthSchema = InferSchemaType<typeof AuthSchema>;