express_javscript_webframe

D:\code3\socketio_express_mongodb\ExpressJS-SocketIO-Boilerplate\config.js

/**
 * Web server port
 */
const SERVER_PORT = 3005;

/**
 * Session settings
 */
const SESSION_SECRET = 'Z>lFs46=B)$u(742x5(iEH6k&m';

/**
 * MongoDB configuration settings
 *
 * Note:
 *  - If you use cloud service like mongodb.com/cloud, you need to change to CONNECTION_TYPE to 'mongodb+srv'!
 *  - DB_QUERY_PARAMS is optional, but if you use cloud service like mongodb.com/cloud,
 *    then the following query params is recommend: '?retryWrites=true&w=majority'
 */
// `mongodb+srv://song:song666@cluster0.tksyrkb.mongodb.net/?retryWrites=true&w=majority`,

const CONNECTION_TYPE = 'mongodb';
const DB_USERNAME = '';
const DB_PASSWORD = '';
const DB_HOST = 'localhost';
const DB_PORT = '27017';
const DB_NAME = 'express-boilerplate';
const DB_QUERY_PARAMS = '';

/**
 * SSL / HTTPS settings
 * ------------------------
 * if HTTPS is true, the PRIVATE_KEY_PATH, CERTIFICATE_PATH and CA_PATH MUST be correctly located.
 *
 * PRIVATE_KEY_PATH is the path where the privkey.pem file is located
 * CERTIFICATE_PATH is the path where the cert.pem file is located
 * CA_PATH is the path where the chain.pem file is located
 */
const HTTPS_ENABLED = false;
const PRIVATE_KEY_PATH = '/opt/psa/var/modules/letsencrypt/etc/live/YOUR-DOMAIN-NAME.com/privkey.pem';
const CERTIFICATE_PATH = '/opt/psa/var/modules/letsencrypt/etc/live/YOUR-DOMAIN-NAME.com/cert.pem';
const CA_PATH = '/opt/psa/var/modules/letsencrypt/etc/live/YOUR-DOMAIN-NAME.com/chain.pem';

/**
 * Swagger UI settings
 * ------------------------
 * Swagger UI is a collection of HTML, Javascript, and CSS assets
 * that dynamically generate beautiful documentation from a Swagger-compliant API.
 *
 * You can visit the Swagger API documentation on /api-docs
 * Example: http://localhost:3005/api-docs/
 */
const SWAGGER_SETTINGS = {
    enableSwaggerUI: true,
    swaggerDefinition: {
        info: {
            title: 'Express.js & Socket.io server',
            description: 'Express.js endpoint API documentation.',
            version: '1.0.0',
        },
        basePath: '/',
        produces: ['application/json'],
        schemes: ['http', 'https'],
    },
    basedir: __dirname, //app absolute path
    files: ['./routes/**/*.js'], //Path to the API handle folder
};

module.exports = {
    SERVER_PORT,
    SESSION_SECRET,
    CONNECTION_TYPE,
    DB_USERNAME,
    DB_PASSWORD,
    DB_HOST,
    DB_PORT,
    DB_NAME,
    DB_QUERY_PARAMS,
    HTTPS_ENABLED,
    PRIVATE_KEY_PATH,
    CERTIFICATE_PATH,
    CA_PATH,
    SWAGGER_SETTINGS,
};

D:\code3\socketio_express_mongodb\ExpressJS-SocketIO-Boilerplate\seed.js

const mongoose = require('mongoose');
const srvConfig = require('./config');
const db = mongoose.connection;
const { CONNECTION_TYPE, DB_HOST, DB_USERNAME, DB_PASSWORD, DB_PORT, DB_NAME, DB_QUERY_PARAMS } = srvConfig;
const dbAuthString = DB_USERNAME && DB_PASSWORD ? `${srvConfig.DB_USERNAME}:${srvConfig.DB_PASSWORD}@` : '';
require('./database/model/users');
const Users = mongoose.model('Users');

mongoose
    .connect(`${CONNECTION_TYPE}://${dbAuthString}${DB_HOST}:${DB_PORT}/${DB_NAME}${DB_QUERY_PARAMS}`, {
        useNewUrlParser: true,
        useUnifiedTopology: true,
    })
    .then(() => {
        return seedUsers();
    })
    .catch(err => {
        console.log(err);
    })
    .then(() => {
        console.log('Database successfully seeded!');
        db.close();
    });

async function seedUsers() {
    await Users.deleteMany();
    await Users.insertMany([
        {
            name: 'John Doe',
            username: 'john',
            password: '$2a$10$KPtehsbArEr3XlIbNOOHOu7/N4s6ha31ZZ2jDngQ.jvFToDs5mNdO', //password123
        },
        {
            name: 'Jane Roe',
            username: 'jane',
            password: '$2a$10$M8R.EalzDPC.ZNz4K.SqMO87KQp0Paq3Qv9xyTG6LHJobNyViWFHi', //securepassword1
        },
    ]);
}

D:\code3\socketio_express_mongodb\ExpressJS-SocketIO-Boilerplate\server.js

'use strict';
const express = require('express');
const app = express();
const http = require('http');
const cors = require('cors');
const session = require('express-session');
const bodyParser = require('body-parser');
const cookieParser = require('cookie-parser');
// swagger ui
const expressSwagger = require('express-swagger-generator')(app);

const srvConfig = require('./config');

const mongoose = require('mongoose');
mongoose.set('strictQuery', false);

const { CONNECTION_TYPE, DB_HOST, DB_USERNAME, DB_PASSWORD, DB_PORT, DB_NAME, DB_QUERY_PARAMS } = srvConfig;
const dbAuthString = DB_USERNAME && DB_PASSWORD ? `${srvConfig.DB_USERNAME}:${srvConfig.DB_PASSWORD}@` : '';

let httpServer;

/**
 * Configure middleware
 */
app.use(
    cors({
        // origin: `http://localhost:${srvConfig.SERVER_PORT}`,
        origin: function (origin, callback) {
            return callback(null, true);
        },
        optionsSuccessStatus: 200,
        credentials: true,
    }),

    session({
        saveUninitialized: true,
        secret: srvConfig.SESSION_SECRET,
        resave: true,
    }),

    cookieParser(),
    bodyParser.json()
);

/**
 * Include all API Routes
 */
app.use('/api', require('./routes/api'));

/**
 * Swagger UI documentation
 */
if (srvConfig.SWAGGER_SETTINGS.enableSwaggerUI) expressSwagger(srvConfig.SWAGGER_SETTINGS);

/**
 * Configure http(s)Server
 */
if (srvConfig.HTTPS_ENABLED) {
    const privateKey = fs.readFileSync(srvConfig.PRIVATE_KEY_PATH, 'utf8');
    const certificate = fs.readFileSync(srvConfig.CERTIFICATE_PATH, 'utf8');
    const ca = fs.readFileSync(srvConfig.CA_PATH, 'utf8');

    // Create a HTTPS server
    httpServer = https.createServer({ key: privateKey, cert: certificate, ca: ca }, app);
} else {
    // Create a HTTP server
    httpServer = http.createServer({}, app);
}

/**
 * Start http server & connect to MongoDB
 */
httpServer.listen(srvConfig.SERVER_PORT, () => {
    // 启动成功
    console.log('启动成功');
    console.log(`http://localhost:${srvConfig.SERVER_PORT}`);

    mongoose.connect(
        `${CONNECTION_TYPE}://${dbAuthString}${DB_HOST}:${DB_PORT}/${DB_NAME}${DB_QUERY_PARAMS}`,
        {
            useNewUrlParser: true,
            useUnifiedTopology: true,
        },
        () => {
            console.log(`Server started on port ${srvConfig.SERVER_PORT}`);
        }
    );
});

D:\code3\socketio_express_mongodb\ExpressJS-SocketIO-Boilerplate\database\model\users.js

const mongoose = require('mongoose');

const usersSchema = new mongoose.Schema({
    name: {
        type: String,
        required: true,
    },
    username: {
        type: String,
        required: true,
    },
    password: {
        type: String,
        required: false,
    }
});

mongoose.model("Users", usersSchema);

module.exports = usersSchema;

D:\code3\socketio_express_mongodb\ExpressJS-SocketIO-Boilerplate\routes\api.js

const express = require('express');
const api = express.Router();
const v1Route = require('./v1/init');

api.use('/v1', v1Route);

module.exports = api;

D:\code3\socketio_express_mongodb\ExpressJS-SocketIO-Boilerplate\routes\v1\init.js

const express = require('express');
const init = express.Router();

const authRoute = require('./auth/auth');

init.get('/', async function (req, res, next) {
    res.json({
        version: 1.0,
        name: 'Express.js & Socket.io API boilerplate',
    });
});

/**
 * Configure here all routes
 */
init.use('/auth/', authRoute);

module.exports = init;

D:\code3\socketio_express_mongodb\ExpressJS-SocketIO-Boilerplate\routes\v1\auth\auth.js

const express = require('express');
const authRouter = express.Router();

const passport = require('passport');
const flash = require('connect-flash');

authRouter.use(passport.initialize());
authRouter.use(passport.session());
authRouter.use(flash());

authRouter.post('/login', function (req, res, next) {
    console.log('login~~');
    return res.json({
        msg: 'login success',
    });
});

authRouter.post('/register', async (req, res) => {
    let { name, username, password } = req.body;
    console.log('register~~');
    return res.json({
        msg: 'register success',
    });
});

module.exports = authRouter;