介绍

1、封装、简化、模型化数据库操作
2、支持查看执行的sql语句

基础库

大于2.8.1

代码片段DEMO

小程序demo: https://developers.weixin.qq.com/s/oXiGFFmI7mia
说明文档: https://www.yuque.com/docs/share/80cbef90-f262-4d2a-b245-079bc462d5e3

如何使用

一、小程序端
1、下载wx-cloud-db-falsework
npm i wx-cloud-db-falsework
2、将wx-cloud-db-falsework.min.js拷贝到小程序项目中，如小程序根目录下的lib文件夹内

3、在app.js中引入wx-cloud-db-falsework.min.js，使用重写过的Page，和原生Page一致，只是增加了use属性

// 根目录/app.js
import { page } from './lib/wx-cloud-db-falsework.min'
Page = page

App({
  onLaunch: function () {}
}

4、创建模型，如： Order，根目录/model/order.js，集合名，默认为model名，首字母会强制小写

// 根目录/model/order.js
import { Model, Controller } from '../lib/wx-cloud-db-falsework.min'

class Order extends Model {
  constructor(o) {
    let t = super(o)
    return t
  }
}
// collectionName 集合名，默认为model名，如Order默认为order，首字母会小写
// collectionKey  集合主键，默认_id
const Odr = Order.init({ env: '环境ID', cloud: wx.cloud [, collectionName = '集合名称', , collectionKey = '主键字段名'] })

export { Odr as Order, Controller }

5、创建控制器，如： Order的controller，根目录/controller/order.js

// 根目录/controller/order.js
import { Order, Controller as Base } from '../model/order'

class Controller extends Base {
    constructor(o){
        super(o)
    }
  	// 在控制器里可以自己封装一些业务功能方法
    getById(id){
        return Order.find(id)
    }
}
let controller = new Controller(Order)
export { controller }

6、在页面中通过use配置需要使用的控制器，控制器实例会挂载在页面实例上，直接通过 this.控制器实例 即可访问，页面: 根目录/pages/index/index.js

// 根目录/pages/index/index.js
import { DB } from '../../lib/wx-cloud-db-falsework.min'
Page({
  use:{
    Order: require('../../controller/order.js')
  },
  data:{},
  onLoad: async function() {
  	// 直接通过 this.控制器实例 即可访问控制器的封装的方法
    await this.Order.getById(1).then(res=>{
      console.log(res)
      // res 可为 DB.DbError实例 或者 DB.DbRes实例
      // 为DB.DbError实例，表示数据库操作异常
      // 为DB.DbRes实例，表示数据库操作正常，而DB.DbRes又包括了DB.DbResultJson和DB.DbResultArray子实例
      // DB.DbResultJson实例说明结果为JSON对象，DB.DbResultArray实例则说明结果为Array对象
    })
    
    // 页面中也可以通过 this.(控制器实例名+'Md')访问模型的方法
    let row = await this.OrderMd.find('xxxx')
    
    // 页面中也可以通过 this.(控制器实例名+'Dd')访问原生db对象，进行原生操作
    let doc = await this.OrderDb.collection('xxx').doc(xx).get()
  }
}

二、云函数端
1、配置云函数package.json，添加wx-cloud-db-falsework

"dependencies": {
    "wx-cloud-db-falsework": "latest",
    "wx-server-sdk": "^2.1.2"
}

2、配置云函数package.json，添加wx-cloud-db-falsework

const cloud = require('wx-server-sdk')
let { Model, DB } =  require('wx-cloud-db-falsework')

# order模型
class Order extends Model {
  constructor(o) {
    let t = super(o)
    return t
  }
}

exports.main = async (event, context) => {
  const Odr = Order.init({ env: '环境ID', cloud })

  return await Odr.add({ _id: (new Date().getTime())+'add'})
}

数据库操作

添加记录

以上述Order模型为例，在页面中添加记录

// 使用model.add(data)添加记录, data为数据json对象或array对象
// 添加一条记录
let res = await this.OrderMd.add({ a:1, b:2 })
// 返回DbResultJson对象 {_id:'xxxx'}

// 添加多条记录
res = await this.OrderMd.add([{	a:1, b:2 }, { a:3, b:4 }])
// 返回DbResultArray对象 [{_id:'xxxx'},{_id:'xxxx'}]

// 支持原生参数
res = await this.OrderMd.add({ data:{ a:1, b:2 } })
res = await this.OrderMd.add({ data: [{	a:1, b:2 }, { a:3, b:4 }] })

// 支持回调函数
this.OrderMd.add({ data:{ a:1, b:2 }, success(r){
  // r 为 DB.DbError实例 或者 DB.DbRes实例
}, fail(e){
	// e 为 DB.DbError实例
}, complete(r){
  // r 为 DB.DbError实例 或者 DB.DbRes实例
} })

this.OrderMd.add({ data:[{	a:1, b:2 }, { a:3, b:4 }], success(r){
  // r 为 DB.DbError实例 或者 DB.DbRes实例
}, fail(e){
	// e 为 DB.DbError实例
}, complete(r){
  // r 为 DB.DbError实例 或者 DB.DbRes实例
} })

删除记录

以上述Order模型为例，在页面中删除记录

// 使用model.remove(where)删除记录, where为删除添加，可为空
// 根据条件删除记录
let res = await this.OrderMd.where({ _id: 'xxx', abc: 123 }).remove()
res = await this.OrderMd.remove({ _id: 'xxx', abc: 123 })
// 根据主键删除
res = await this.OrderMd.doc('xxx').remove()
// 返回DB.DbError对象或DB.DbRes对象 {removed:Number}

// 支持回调函数
this.OrderMd.where({ _id: 'xxx', abc: 123 }).remove({ success(r){
  // r 为 DB.DbError实例 或者 DB.DbRes实例
}, fail(e){
	// e 为 DB.DbError实例
}, complete(r){
  // r 为 DB.DbError实例 或者 DB.DbRes实例
} })

this.OrderMd.remove({ where:{ _id: 'xxx', abc: 123 }, success(r){
  // r 为 DB.DbError实例 或者 DB.DbRes实例
}, fail(e){
	// e 为 DB.DbError实例
}, complete(r){
  // r 为 DB.DbError实例 或者 DB.DbRes实例
} })

查询记录

查询一条记录

以上述Order模型为例，在页面中查询记录

// 使用model.find()查询记录
// 根据条件查询记录
let res = await this.OrderMd.where({ _id: 'xxx', abc: this.OrderMd._.eq(123) }).find()
res = await this.OrderMd.find({ _id: 'xxx', abc: this.OrderMd._.eq(123) })
// 根据主键查询记录
res = await this.OrderMd.doc('xxx').find()
res = await this.OrderMd.find('xxx')
// 返回DB.DbError对象或DB.DbRes对象 {_id:'xxx', ....}

// 使用model.where().get()查询记录
// 根据条件查询记录
let res = await this.OrderMd.where({ _id: 'xxx' }).get()
// 返回DB.DbError对象或DB.DbRes对象 [{_id:'xxx', ....}]

// 根据主键查询记录
res = await this.OrderMd.doc('xxx').get()
// 返回DB.DbError对象或DB.DbRes对象 {_id:'xxx', ....}

// 支持回调函数
this.OrderMd.find({ where:{ _id: 'xxx', abc: 123 }, success(r){
  // r 为 DB.DbError实例 或者 DB.DbRes实例
}, fail(e){
	// e 为 DB.DbError实例
}, complete(r){
  // r 为 DB.DbError实例 或者 DB.DbRes实例
} })

this.OrderMd.where({ _id: 'xxx', abc: 123 }).find({ success(r){
  // r 为 DB.DbError实例 或者 DB.DbRes实例
}, fail(e){
	// e 为 DB.DbError实例
}, complete(r){
  // r 为 DB.DbError实例 或者 DB.DbRes实例
} })

this.OrderMd.where({ _id: 'xxx' }).get({ success(r){
  // r 为 DB.DbError实例 或者 DB.DbRes实例
}, fail(e){
	// e 为 DB.DbError实例
}, complete(r){
  // r 为 DB.DbError实例 或者 DB.DbRes实例
} })

this.OrderMd.doc('xxx').get({ success(r){
  // r 为 DB.DbError实例 或者 DB.DbRes实例
}, fail(e){
	// e 为 DB.DbError实例
}, complete(r){
  // r 为 DB.DbError实例 或者 DB.DbRes实例
} })

特殊支持：

// json字符串条件
let res = await this.OrderMd.find(`{ _id: 'xxx' }`)
res = await this.OrderMd.where(`{ _id: 'xxx' }`).find()
// 使用command时需要加this
res = await this.OrderMd.find(`{ _id: this._.eq('xxx') }`)
res = await this.OrderMd.where(`{ _id: this._.eq('xxx') }`).find()

查询多条记录

// 使用model.findAll()查询记录
// 根据条件查询记录
let res = await this.OrderMd.where({ abc: 'xxx', abc: this.OrderMd._.eq(123) }).findAll()
res = await this.OrderMd.findAll({ abc: 'xxx', abc: this.OrderMd._.eq(123) })
// 返回DB.DbError对象或DB.DbRes对象 [{_id:'xxx', ....}]

// 使用model.where().get()查询记录
// 根据条件查询记录
let res = await this.OrderMd.where({ _id: 'xxx' }).get()
// 返回DB.DbError对象或DB.DbRes对象 [{_id:'xxx', ....}]

// 支持回调函数
this.OrderMd.findAll({ where:{ abc: 'xxx' }, success(r){
  // r 为 DB.DbError实例 或者 DB.DbRes实例
}, fail(e){
	// e 为 DB.DbError实例
}, complete(r){
  // r 为 DB.DbError实例 或者 DB.DbRes实例
} })

this.OrderMd.where({ abc: 'xxx' }).findAll({ success(r){
  // r 为 DB.DbError实例 或者 DB.DbRes实例
}, fail(e){
	// e 为 DB.DbError实例
}, complete(r){
  // r 为 DB.DbError实例 或者 DB.DbRes实例
} })

this.OrderMd.where({ _id: 'xxx' }).get({ success(r){
  // r 为 DB.DbError实例 或者 DB.DbRes实例
}, fail(e){
	// e 为 DB.DbError实例
}, complete(r){
  // r 为 DB.DbError实例 或者 DB.DbRes实例
} })

this.OrderMd.doc('xxx').get({ success(r){
  // r 为 DB.DbError实例 或者 DB.DbRes实例
}, fail(e){
	// e 为 DB.DbError实例
}, complete(r){
  // r 为 DB.DbError实例 或者 DB.DbRes实例
} })

特殊支持：

// json字符串条件
let res = await this.OrderMd.findAll(`{ abc: 'xxx' }`)
res = await this.OrderMd.where(`{ abc: 'xxx' }`).findAll()
// 使用command时需要加this
res = await this.OrderMd.findAll(`{ abc: this._.eq('xxx') }`)
res = await this.OrderMd.where(`{ abc: this._.eq('xxx') }`).findAll()

更新记录

以上述Order模型为例，在页面中查询记录

// 使用model.update()更新记录
// 根据条件更新记录
let res = await this.OrderMd.where({ _id: 'xxx', abc: this.OrderMd._.eq(123) }).update({ cde: 456 })
res = await this.OrderMd.update({ cde: 456 }, { _id: 'xxx', abc: this.OrderMd._.eq(123) })
// 根据主键更新记录
res = await this.OrderMd.doc('xxx').update({ cde: 456 })
// 返回DB.DbError对象或DB.DbRes对象 {updated:Number}

// 支持回调函数
this.OrderMd.where({ _id: 'xxx', abc: this.OrderMd._.eq(123) }).update({ data:{ cde: 456 }, success(r){
  // r 为 DB.DbError实例 或者 DB.DbRes实例
}, fail(e){
	// e 为 DB.DbError实例
}, complete(r){
  // r 为 DB.DbError实例 或者 DB.DbRes实例
} })

聚合操作

以上述Order模型为例，在页面中查询记录

// 使用model.aggregate()开始聚合操作
let res = await this.OrderMd.aggregate()
.addFields({
    test: 1
})
.match({
    test: 1
})
... // 其他聚合操作
.end()
// 返回DB.DbError对象或DB.DbRes对象 [{_id:'xxx', ....}, ...]

数据监听

以上述Order模型为例，在页面中查询记录

// 使用model.wcthis(ops)监听记录，
let res = await this.OrderMd.wcthis({
	onChange(res){
  		// 监听操作
  	},
	onError(err){
  		// 监听出错
 	}
}).where({ _id: 'xxx' }).update({ cde: 456 })

// 使用原生watch方法监听记录，
await this.OrderMd.where({ _id: 'xxx' }).watch({
	onChange(res){
  		// 监听操作
 	},
 	onError(err){
  		// 监听出错
 	}
})
let res = this.OrderMd.where({ _id: 'xxx' }).update({ cde: 456 })

数据库操作结果

数据库操作结果返回 DB.DbError实例 或者 DB.DbRes实例

add结果

res = model.add(…) 添加一条数据返回 { _id: ‘xxx’ } ，添加多条时返回 [{ _id: ‘xxx’ }, { _id: ‘xxx’ }]
返回的结果可以直接调用update，remove方法，如：

// 添加一条记录
let res = await this.OrderMd.add({ a:1, b:2 })
// 返回DbResultJson对象 {_id:'xxxx'}
if(res instanceof DB.DbRes){
  // 更新操作，更新刚新增的这条记录
  let back = res.update({c: 555})
  // 删除操作，删除刚新增的这条记录
  back = res.remove()
}

// 添加多条记录
res = await this.OrderMd.add([{	a:1, b:2 }, { a:3, b:4 }])
// 返回DbResultArray对象 [{_id:'xxxx'},{_id:'xxxx'}]
if(res instanceof DB.DbRes){
  // 更新操作，更新刚新增的这几条记录
  let back = res.update({c: 555})
  // 删除操作，删除刚新增的这几条记录
  back = res.remove()
}

remove结果

res = model.remove() 删除记录返回 { removed:Number }

// 删除记录
let res = await this.OrderMd.remove({ a:1, b:2 })
// 返回DbResultJson对象 {removed:Number}
if(res instanceof DB.DbRes){
  	if(res.removed){
  		// 删除成功
	}else{
  		// 删除失败
  	}
}else{
  consloe.errr(res)
}

find/findAll/get结果

res = model.find() 返回 { _id: ‘xxx’, … }
res = model.findAll/get() 返回 [{ _id: ‘xxx’, … }, { _id: ‘xxx’, … }, …]
返回的结果可以直接调用update，remove方法，如：

// 添加一条记录
let res = await this.OrderMd.doc('xxx').find()
// 返回DbResultJson对象 {_id:'xxxx'}
if(res instanceof DB.DbRes){
  // 更新操作，更新这条记录
  // let back = res.update({c: 555})
  
  // 删除操作，删除这条记录
  let back = res.remove()
}

// 添加多条记录
res = await this.OrderMd.where({abc:123}).findAll()
res = await this.OrderMd.where({abc:123}).get()
// 返回DbResultArray对象 [{ _id: 'xxx', ... }, { _id: 'xxx', ... }, ...]
if(res instanceof DB.DbRes){
  // 更新操作，更新这几条记录
  // let back = res.update({c: 555})
  // 删除操作，删除这几条记录
  let back = res.remove()
}

update结果

res = model.update() 更新数据返回 { updated: Number }

// 更新记录
let res = await this.OrderMd.where({ a:1, b:2 }).update({c:555})
res = await this.OrderMd.doc('xxx').update({c:555})
// 返回DbResultJson对象 {update:Number}
if(res instanceof DB.DbRes){
  	if(res.update){
  		// 更新成功
	}else{
  		// 更新失败
  	}
}else{
  consloe.errr(res)
}

查看SQL语句

以上述Order模型为例，在页面中查询记录
数据库操作结果返回 DB.DbRes 对象时，可查看执行的SQL语句

var res = await this.OrderMd.add({ a:1, b:2 })
console.log(res.sql)

var res = await this.OrderMd.remove({ a:1, b:2 })
console.log(res.sql)

var res = await this.OrderMd.doc('xxx').find()
console.log(res.sql)

var res = await this.OrderMd.where({ a:1, b:2 }).update({c:555})
console.log(res.sql)

var res = await this.OrderMd.aggregate()
.addFields({
    	test: 1
})
.match({
    test: 1
})
.end()
console.log(res.sql)

ps: 可以拿去练练手，不保证无BUG