Node generates and verifies tokens (typescript syntax)

1、 First installation jsonwebtoken

(c)npm install jsonwebtoken -S

2、 According to the login information sent by the front end , Generate corresponding token

import { Router,Request,Response } from "express";
import jwt from 'jsonwebtoken';

export default (router:Router) => {
    router.post('/',(req:Request,res:Response) => {
        /* 
        req.body     Encrypted token Information here is {user:admin,pass:admin}
        'Agwenbi'    Encrypted key , Make an appointment with yourself 
        expiresIn    Expiration time , Unit second 
        */
        const token = jwt.sign({
            ...req.body
        },'Agwenbi',{
            expiresIn: (60 * 60 * 24) * 7//7 Days 
        });
        res.status(200).json({//token Send the information to the front end 
            code:0,
            msg:' The request is successful ',
            token
        });
    });
    return router;
}

// The front end receives token And save token Information 
localStorage.setItem('xmds-token',loginResult.token);

3、 The front-end request header is added by default token Information

import axios,{AxiosInstance, AxiosRequestConfig, AxiosResponse} from 'axios';
import qs from 'qs';

class CreateAxios {
    public http:AxiosInstance
    constructor(){
        this.http = axios.create({
            timeout:10 * 1000,
            baseURL:'http://localhost:8090'
        });
    }
}

class AxiosReq extends CreateAxios {// Request interceptor 
    constructor(){
        super();
        this.axiosReq();
    }
    axiosReq(){
        this.http.interceptors.request.use((config:AxiosRequestConfig) => {
            const token = localStorage.getItem('xmds-token');
            if(token){// There is token, Default plus token
                config.headers.common['Authorization'] = token;
            }
            if(config.method === 'post'){
                config.data = qs.stringify(config.data);
            }
            return config;
        },error => {
            console.log(error);
        })
    }
}

class AxiosRes extends AxiosReq {// Response interceptors 
    constructor(){
        super();
        this.axiosRes();
    }
    axiosRes(){
        this.http.interceptors.response.use((response:AxiosResponse<any>) => {
            const result = Promise.resolve(response.data);
            return result;
        },error => {
            console.log(error);
        })
    }
}

const http:AxiosInstance = new AxiosRes().http;
export default http;

4、node Global routing , verification token

import jwt from 'jsonwebtoken';
const noTokenUrl = ['/login'];// No validation required token Request 
app.use((req:Request,res:Response,next:NextFunction) => {
    const token = req.headers.authorization;
    if(token){// There is token
        jwt.verify(token,'Agwenbi',(error,decoded) => {//Agwenbi Indicates the key , Refer to the key set in step 2 
            const tokenFlag = error?.name;
            if(tokenFlag === 'TokenExpiredError'){//token Be overdue 
                res.status(200).json({
                    code:401,
                    msg:'token Be overdue '
                });
            }else if(tokenFlag === 'JsonWebTokenError'){//token Validation failed 
                res.status(200).json({
                    code:401,
                    msg:' Invalid token'
                });
            }else{//token Not expired , And the verification passed 
                next();
            }
        });
    }else{// non-existent token
        if(noTokenUrl.includes(req.url)){// Whether it is unnecessary token Under the verified route 
            next();
        }else{// Not in the accepted route , And not carried token
            res.status(200).json({
                code:401,
                msg:' Invalid token'
            });
        }
    }
});