module.exports = {
	mysqlConf : {
  	host: 'localhost',
    user: 'root',
    password: 'liugezhou1205',
    port: '3306',
    database: 'imooc_lego_course',
  }
}

const mysql = require('mysql2/promise')
const { mysqlConf } = require('../config/dev')   //这里加载dev

async function testMysqlConn () {
	const conn = await mysql.createConnection(mysqlConf)
  const [rows] = await conn.execute('select now()')
  return rows
}

testMysqlConn().then(res => console.log(res)

// src/db/seq/utils/conn-test.js
const seq = require('../seq')

seq.authenticate()
	.then(()=>{
		console.log('ok')
	})
	.catch(()=>{
		console.log('fail')
	})
	.finally(()=>{
		process.exit()
	})

// src/db/seq/seq.js
const Sequelize = require('sequelize')
const {mysqlConf } = require('../config/dev') 
const { isPrd, isTest } = require('../../utils/env')

//连接配置
const { database, user, password, host, port } = mysqlConf
const conf = {
	host,
  port,
  dialect:'mysql'
}

//测试环境不打印日志
if(isTest){
	 conf.logging = () => {} // 默认是 console.log
}

// 线上环境用 链接池
if (isPrd) {
    conf.pool = {
        max: 5, // 连接池中最大连接数量
        min: 0, // 连接池中最小连接数量
        idle: 10000, // 如果一个线程 10 秒钟内没有被使用过的话，那么就释放线程
    }
}

// 创建连接
const seq = new Sequelize(database, user, password, conf)

module.exports = seq

// userModel
// src/models/UserModel.js
const seq = require('../db/seq/seq')
const { STRING, DATE, BOOLEAN } = require('../db/seq/types')

const User = seq.define('user', {
    username: {
        type: STRING,
        allowNull: false,
        unique: 'username', // 不要用 unique: true, 
        comment: '用户名，唯一',
    },
    password: {
        type: STRING,
        allowNull: false,
        comment: '密码',
    }
})

module.exports = User

#!/usr/bin/env node

………………

const syncDb = require('../src/db/seq/utils/sync-alter')

………………

// 先同步 mysql 数据表
syncDb().then(() => {
    // 再启动服务
    server.listen(port)
    ………………
})

const path = require('path')
const simpleGit = require('simple-git')
const seq = require('../seq')
const { isDev } = require('../../../utils/env')

// 获取所有 seq model
require('require-all')({
    dirname: path.resolve('src', 'models'), // src/models 中可能会有 mongoose 的 model ，不过这里获取了也没关系
    filter: /\.js$/,
    excludeDirs: /^\.(git|svn)$/,
    recursive: true, // 递归
})

// 同步数据表
async function syncDb() {
    let needToSyncDb = true
    // 只适用于开发环境！！！
    if (isDev) {
      ………………
        if (fileChanged.length) {
          …………
            if (!changedDbFiles) needToSyncDb = false
        }
    }

    if (needToSyncDb) {
        await seq.sync({ alter: true })
    }
}

module.exports = syncDb

// src/config/envs/dev.js

mongodbConf: {
  host: 'localhost',
  port: '27017',
  dbName: 'imooc_lego_course',
},

const mongoose = require('mongoose')
const { mongodbConf } = require('../config/index')

const { host, port, dbName, user, password } = mongodbConf

// 拼接连接字符串
let url = `mongodb://${host}:${port}` // dev 环境
if (user && password) {
    url = `mongodb://${user}:${password}@${host}:${port}` // prd 环境
}

mongoose.set('useCreateIndex', true)
mongoose.set('useFindAndModify', false)

// 开始连接（ 使用用户名和密码时，需要 `?authSource=admin` ）
mongoose.connect(`${url}/${dbName}?authSource=admin`, {
    useNewUrlParser: true,
    useUnifiedTopology: true,
})

// 连接对象
const db = mongoose.connection

db.on('error', err => {
    console.error('mongoose connect error', err)
})

 // 演示注释掉即可
 db.once('open', () => {
     // 用以测试数据库连接是否成功
     console.log('mongoose connect success')
 })

/**
 * @description 作品内容 Model ，存储到 Mongodb
 * @author liugezhou
 */

const mongoose = require('../db/mongoose')

// 两个 model 公用一个 schema
const contentSchema = mongoose.Schema(
    {
        // 页面的组件列表
        components: [Object],
        // 页面的属性，如页面背景图片
        props: Object,
        // 配置信息，如微信分享配置
        setting: Object,
    },
    { timestamps: true }
)

// 未发布的内容
const WorkContentModel = mongoose.model('workContent', contentSchema)

// 发布的内容
const WorkPublishContentModel = mongoose.model('workPublishContent', contentSchema)

module.exports = {
    WorkContentModel,
    WorkPublishContentModel,
}

# Dockerfile
FROM node:14
WORKDIR /app
COPY . /app

# 设置时区
RUN ln -sf /usr/share/zoneinfo/Asia/Shanghai /etc/localtime && echo 'Asia/Shanghai' >/etc/timezone

CMD npm i && npm run prd-dev && npx pm2 log

/**
 * @description 封装 jwt 插件
 * @author liugezhou
 */

const jwtKoa = require('koa-jwt')
const { JWT_SECRET, JWT_IGNORE_PATH } = require('../config/constant')

module.exports = jwtKoa({
    secret: JWT_SECRET,
    cookie: 'jwt_token', // 使用 cookie 存储 token
}).unless({
    // 定义哪些路由忽略 jwt 验证
    path: JWT_IGNORE_PATH,
})

"scripts": {
	 "test:local": "cross-env NODE_ENV=test_local jest --runInBand  --passWithNoTests --colors --forceExit",
}

describe('test demo', () => {
    test('1+1 = 2', () => {
        expect(1 + 1).toBe(2)
    })
})

const os = require('os')
const cpuCoreLength = os.cpus().length // CPU 几核

module.exports = {
    apps: [
      {
        name: 'your-server-name',
        script: 'bin/www',
        // watch: true, // 无特殊情况，不用实时监听文件，否则可能会导致很多 restart
        ignore_watch: ['node_modules', '__test__', 'logs'],
        // instances: cpuCoreLength, // 线上环境，多进程
        instances: 1, // 测试环境，一个进程即可
        error_file: './logs/err.log',
        out_file: './logs/out.log',
        log_date_format: 'YYYY-MM-DD HH:mm:ss Z', // Z 表示使用当前时区的时间格式
        combine_logs: true, // 多个实例，合并日志
        max_memory_restart: '300M', // 内存占用超过 300M ，则重启,可使用 pm2 monit查看初始内存占用，然后根据初始设置
      }
    ],
}

const MongoClient = require('mongodb')

const url =  'mongodb://localhost:27017'
const dbName = 'myblog'

MongoClient.connect(
    url,
    {
        //配置
         useUnifiedTopology: true 
    },
    (err,client) =>{
        if(err){
            console.error('mongodb  connect error',err)
            return
        }
        // 连接成功
        console.log('mongodb connect success')

        // 切换数据库
        const db = client.db(dbName)
        //关闭连接
        client.close()
    }
)

const MongoClient = require('mongodb')

const url =  'mongodb://localhost:27017'
const dbName = 'myblog'

MongoClient.connect(
    url,
    {
        //配置
         useUnifiedTopology: true 
    },
    (err,client) =>{
        if(err){
            console.error('mongodb  connect error',err)
            return
        }
        // 连接成功
        console.log('mongodb connect success')

        // 切换数据库
        const db = client.db(dbName)

        //集合
        const userCollection = db.collection('users')

        //删除
        userCollection.deleteOne({
            username:'mongodb'
        },(err,result)=>{
                if(err){
                    console.log('user delete error', err)
                    return
                }
                console.log(result)
                client.close()
            }
        )
        //修改
        userCollection.updateOne({
            username:'mongodb'
        },{$set:{username:'mongoose'}},(err,result)=>{
            if(err){
                console.log('user update error', err)
                return
            }
            console.log(result)
            client.close()
        })

        // 新增
        userCollection.insertOne({
            username:'mongodb',
            password:'abc',
            nickname:'mongoose'
        },(err,result) =>{
            if(err){
                console.log('user insert error', err)
                return
            }
            console.log(result)
            client.close()
        })
        // 文档--查询
        userCollection.find().toArray((err,result) => {
            if(err){
                console.log('user find error', err)
                return
            }
            console.log(result)
              //关闭连接
            client.close()
        })
    }
)

const mongoose = require('../db')

// 用Schema定义数据规范
const UserSchema = mongoose.Schema({
    username: {
        type:String,
        required:true,
        unique:true
    },
    password: String,
    nickname: String
})

// Model对应 collection
const User = mongoose.model('user',UserSchema)

module.exports = User

const Blog = require('../models/Blog')

!(async  ()=>{
    // 创建博客
    // const blog = await Blog.create({
    //     title:'liugezhou4',
    //     content:'内容4',
    //     author:'mongoose'
    // })
    // console.log(blog)

    // 查询
//    const blogList =  await Blog.find({author:'mongoose'}).sort({_id:-1})
//    console.log(blogList)

   //修改
   const res = await Blog.findOneAndUpdate(
       { title:'liugezhou'  },
       {content:'new content'},
       {new:true}    
   )
   console.log(res)
})()

const redis = require('redis')
const { REDIS_CONF } = require('../conf/db')

// 创建客户端
const redisClient = redis.createClient(REDIS_CONF.port,REDIS_CONF.host)

redisClient.on('error', err=>{
    console.log('redis error', err)
})